Merge tag 'OTP-19.0' into sverker/19/binary_to_atom-utf8-crash/ERL-474/OTP-14590

38 files changed, 8549 insertions, 11901 deletions

diff --git a/lib/asn1/src/Makefile b/lib/asn1/src/Makefile
index 33cd3cc4c3..38cf2d496a 100644
--- a/lib/asn1/src/Makefile
+++ b/lib/asn1/src/Makefile
@@ -1,18 +1,19 @@
 #
 # %CopyrightBegin%
 # 
-# Copyright Ericsson AB 1997-2013. All Rights Reserved.
+# Copyright Ericsson AB 1997-2016. All Rights Reserved.
 # 
-# The contents of this file are subject to the Erlang Public License,
-# Version 1.1, (the "License"); you may not use this file except in
-# compliance with the License. You should have received a copy of the
-# Erlang Public License along with this software. If not, it can be
-# retrieved online at http://www.erlang.org/.
-# 
-# Software distributed under the License is distributed on an "AS IS"
-# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-# the License for the specific language governing rights and limitations
-# under the License.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 # 
 # %CopyrightEnd%
 #
@@ -43,9 +44,7 @@ RELSYSDIR = $(RELEASE_PATH)/lib/asn1-$(VSN)
 
 EBIN = ../ebin
 
-EVAL_CT_MODULES = asn1ct_eval_ext \
-		  asn1ct_eval_per \
-		  asn1ct_eval_uper
+EVAL_CT_MODULES = asn1ct_eval_ext
 
 CT_MODULES= \
 	asn1ct \
@@ -54,8 +53,8 @@ CT_MODULES= \
 	asn1ct_pretty_format \
 	asn1ct_func \
 	asn1ct_gen \
+	asn1ct_gen_check \
 	asn1ct_gen_per \
-	asn1ct_gen_per_rt2ct \
 	asn1ct_name \
 	asn1ct_constructed_per \
 	asn1ct_constructed_ber_bin_v2 \
@@ -138,7 +137,7 @@ $(EBIN)/asn1ct_func.$(EMULATOR): asn1ct_func.erl
 
 asn1ct_eval_%.erl: asn1ct_eval_%.funcs
 	$(gen_verbose)erl -pa $(EBIN) -noshell -noinput \
-	   -run prepare_templates gen_asn1ct_eval $< >$@
+	   -run prepare_templates gen_asn1ct_eval $<
 
 $(APP_TARGET): $(APP_SRC) ../vsn.mk
 	$(vsn_verbose)sed -e 's;%VSN%;$(VSN);' $< > $@
@@ -183,7 +182,7 @@ RT_TEMPLATES_TARGET = $(RT_TEMPLATES:%=%.$(EMULATOR))
 
 asn1ct_rtt.erl: prepare_templates.$(EMULATOR) $(RT_TEMPLATES_TARGET)
 	$(gen_verbose)erl -noshell -noinput -run prepare_templates gen_asn1ct_rtt \
-           $(RT_TEMPLATES_TARGET) >asn1ct_rtt.erl
+           $(RT_TEMPLATES_TARGET)
 
 prepare_templates.$(EMULATOR): prepare_templates.erl
 	$(V_ERLC) prepare_templates.erl
@@ -208,6 +207,7 @@ $(EBIN)/asn1ct_constructed_per.beam: asn1ct_constructed_per.erl asn1_records.hrl
 $(EBIN)/asn1ct_func.beam: asn1ct_func.erl
 $(EBIN)/asn1ct_gen.beam: asn1ct_gen.erl asn1_records.hrl
 $(EBIN)/asn1ct_gen_ber_bin_v2.beam: asn1ct_gen_ber_bin_v2.erl asn1_records.hrl
+$(EBIN)/asn1ct_gen_check.beam: asn1_records.hrl
 $(EBIN)/asn1ct_gen_per.beam: asn1ct_gen_per.erl asn1_records.hrl
 $(EBIN)/asn1ct_gen_per_rt2ct.beam: asn1ct_gen_per_rt2ct.erl asn1_records.hrl
 $(EBIN)/asn1ct_imm.beam: asn1ct_imm.erl
diff --git a/lib/asn1/src/asn1.app.src b/lib/asn1/src/asn1.app.src
index f2ee8deb75..1f8805ff5e 100644
--- a/lib/asn1/src/asn1.app.src
+++ b/lib/asn1/src/asn1.app.src
@@ -10,5 +10,6 @@
 	asn1db
 		]},
   {env, []},
-  {applications, [kernel, stdlib]}
+  {applications, [kernel, stdlib]},
+  {runtime_dependencies, ["stdlib-2.0","kernel-3.0","erts-7.0"]}
   ]}.
diff --git a/lib/asn1/src/asn1.appup.src b/lib/asn1/src/asn1.appup.src
index 2d11eddfbf..9487d6207d 100644
--- a/lib/asn1/src/asn1.appup.src
+++ b/lib/asn1/src/asn1.appup.src
@@ -1,11 +1,22 @@
+%% -*- erlang -*-
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2014-2016. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
 {"%VSN%",
-% This version does not change anything of the runtime modules
-% Only changes in compile time modules and thus no need for upgrade on target
-[
- ],
- [ 
- ]}.
-
-
-
-
+ [{<<".*">>,[{restart_application, asn1}]}],
+ [{<<".*">>,[{restart_application, asn1}]}]
+}.
diff --git a/lib/asn1/src/asn1_app.erl b/lib/asn1/src/asn1_app.erl
index 9fff96e0bf..d1d8a955c2 100644
--- a/lib/asn1/src/asn1_app.erl
+++ b/lib/asn1/src/asn1_app.erl
@@ -1,13 +1,14 @@
-%% ``The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved via the world wide web at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%% ``Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %% 
 %% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
 %% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
diff --git a/lib/asn1/src/asn1_db.erl b/lib/asn1/src/asn1_db.erl
index 869b36ddbd..557eca0ffd 100644
--- a/lib/asn1/src/asn1_db.erl
+++ b/lib/asn1/src/asn1_db.erl
@@ -1,43 +1,58 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
 %%
 -module(asn1_db).
 
--export([dbstart/1,dbnew/1,dbsave/2,dbput/3,dbget/2]).
+-export([dbstart/1,dbnew/2,dbload/1,dbload/3,dbsave/2,dbput/2,
+	 dbput/3,dbget/2]).
 -export([dbstop/0]).
 
 -record(state, {parent, monitor, includes, table}).
 
 %% Interface
-dbstart(Includes) ->
+dbstart(Includes0) ->
+    Includes = case Includes0 of
+		   [] -> ["."];
+		   [_|_] -> Includes0
+	       end,
     Parent = self(),
     undefined = get(?MODULE),			%Assertion.
     put(?MODULE, spawn_link(fun() -> init(Parent, Includes) end)),
     ok.
 
-dbnew(Module)              -> req({new, Module}).
+dbload(Module, Erule, Mtime) ->
+    req({load, Module, Erule, Mtime}).
+
+dbload(Module) ->
+    req({load, Module, any, {{0,0,0},{0,0,0}}}).
+
+dbnew(Module, Erule)       -> req({new, Module, Erule}).
 dbsave(OutFile, Module)    -> cast({save, OutFile, Module}).
 dbput(Module, K, V)        -> cast({set, Module, K, V}).
+dbput(Module, Kvs)         -> cast({set, Module, Kvs}).
 dbget(Module, K)           -> req({get, Module, K}).
 dbstop()                   -> Resp = req(stop), erase(?MODULE), Resp.
 
 %% Internal functions
+-define(MAGIC_KEY, '__version_and_erule__').
+
 req(Request) ->
     DbPid = get(?MODULE),
     Ref = erlang:monitor(process,DbPid),
@@ -70,48 +85,62 @@ loop(#state{parent = Parent, monitor = MRef, table = Table,
             [{_, Modtab}] = ets:lookup(Table, Mod),
             ets:insert(Modtab, {K2, V}),
             loop(State);
+        {set, Mod, Kvs} ->
+            [{_, Modtab}] = ets:lookup(Table, Mod),
+            ets:insert(Modtab, Kvs),
+            loop(State);
         {From, {get, Mod, K2}} ->
-            Result = case ets:lookup(Table, Mod) of
-                         []            -> opentab(Table, Mod, Includes);
-                         [{_, Modtab}] -> {ok, Modtab}
-                     end,
-            case Result of
-                {ok, Newtab} -> reply(From, lookup(Newtab, K2));
-                _Error       -> reply(From, undefined)
+	    %% XXX If there is no information for Mod, get_table/3
+	    %% will attempt to load information from an .asn1db
+	    %% file, without comparing its timestamp against the
+	    %% source file. This is known to happen when check_*
+	    %% functions for DER are generated, but it could possibly
+	    %% happen in other circumstances. Ideally, this issue should
+	    %% be rectified in some way, perhaps by ensuring that
+	    %% the module has been loaded (using dbload/4) prior
+	    %% to calling dbget/2.
+            case get_table(Table, Mod, Includes) of
+                {ok,Tab} -> reply(From, lookup(Tab, K2));
+                error -> reply(From, undefined)
             end,
             loop(State);
         {save, OutFile, Mod} ->
             [{_,Mtab}] = ets:lookup(Table, Mod),
             ok = ets:tab2file(Mtab, OutFile),
             loop(State);
-        {From, {new, Mod}} ->
+        {From, {new, Mod, Erule}} ->
             [] = ets:lookup(Table, Mod),	%Assertion.
             ModTableId = ets:new(list_to_atom(lists:concat(["asn1_",Mod])), []),
             ets:insert(Table, {Mod, ModTableId}),
+	    ets:insert(ModTableId, {?MAGIC_KEY, info(Erule)}),
             reply(From, ok),
             loop(State);
+	{From, {load, Mod, Erule, Mtime}} ->
+	    case ets:member(Table, Mod) of
+		true ->
+		    reply(From, ok);
+		false ->
+		    case load_table(Mod, Erule, Mtime, Includes) of
+			{ok, ModTableId} ->
+			    ets:insert(Table, {Mod, ModTableId}),
+			    reply(From, ok);
+			error ->
+			    reply(From, error)
+		    end
+	    end,
+	    loop(State);
         {From, stop} ->
             reply(From, stopped); %% Nothing to store
         {'DOWN', MRef, process, Parent, Reason} ->
             exit(Reason)
     end.
 
-opentab(Tab, Mod, []) ->
-    opentab(Tab, Mod, ["."]);
-opentab(Tab, Mod, Includes) ->
-    Base = lists:concat([Mod, ".asn1db"]),
-    opentab2(Tab, Base, Mod, Includes, ok).
-
-opentab2(_Tab, _Base, _Mod, [], Error) ->
-    Error;
-opentab2(Tab, Base, Mod, [Ih|It], _Error) ->
-    File = filename:join(Ih, Base),
-    case ets:file2tab(File) of
-        {ok, Modtab} ->
-            ets:insert(Tab, {Mod, Modtab}),
-            {ok, Modtab};
-        NewErr ->
-            opentab2(Tab, Base, Mod, It, NewErr)
+get_table(Table, Mod, Includes) ->
+    case ets:lookup(Table, Mod) of
+	[{Mod,Tab}] ->
+	    {ok,Tab};
+	[] ->
+	    load_table(Mod, any, {{0,0,0},{0,0,0}}, Includes)
     end.
 
 lookup(Tab, K) ->
@@ -119,3 +148,43 @@ lookup(Tab, K) ->
         []      -> undefined;
         [{K,V}] -> V
     end.
+
+info(Erule) ->
+    {asn1ct:vsn(),Erule}.
+
+load_table(Mod, Erule, Mtime, Includes) ->
+    Base = lists:concat([Mod, ".asn1db"]),
+    case path_find(Includes, Mtime, Base) of
+	error ->
+	    error;
+	{ok,ModTab} when Erule =:= any ->
+	    {ok,ModTab};
+	{ok,ModTab} ->
+	    Vsn = asn1ct:vsn(),
+	    case ets:lookup(ModTab, ?MAGIC_KEY) of
+		[{_,{Vsn,Erule}}] ->
+		    %% Correct version and encoding rule.
+		    {ok,ModTab};
+		_ ->
+		    %% Missing key or wrong version/encoding rule.
+		    ets:delete(ModTab),
+		    error
+	    end
+    end.
+
+path_find([H|T], Mtime, Base) ->
+    File = filename:join(H, Base),
+    case filelib:last_modified(File) of
+	0 ->
+	    path_find(T, Mtime, Base);
+	DbMtime when DbMtime >= Mtime ->
+	    case ets:file2tab(File) of
+		{ok,_}=Ret ->
+		    Ret;
+		_ ->
+		    path_find(T, Mtime, Base)
+	    end;
+	_ ->
+	    path_find(T, Mtime, Base)
+    end;
+path_find([], _, _) -> error.
diff --git a/lib/asn1/src/asn1_records.hrl b/lib/asn1/src/asn1_records.hrl
index 396ba0fcfa..af10c1771c 100644
--- a/lib/asn1/src/asn1_records.hrl
+++ b/lib/asn1/src/asn1_records.hrl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -37,7 +38,7 @@
 -record('ObjectClassFieldType',{classname,class,fieldname,type}).
 
 -record(typedef,{checked=false,pos,name,typespec}).
--record(classdef,{checked=false,pos,name,typespec}).
+-record(classdef, {checked=false,pos,name,module,typespec}).
 -record(valuedef,{checked=false,pos,name,type,value,module}).
 -record(ptypedef,{checked=false,pos,name,args,typespec}).
 -record(pvaluedef,{checked=false,pos,name,args,type,value}).
@@ -45,7 +46,6 @@
 -record(pobjectdef,{checked=false,pos,name,args,class,def}).
 -record(pobjectsetdef,{checked=false,pos,name,args,class,def}).
 
--record(identifier,{pos,val}).
 -record('Constraint',{'SingleValue'=no,'SizeConstraint'=no,'ValueRange'=no,'PermittedAlphabet'=no,
 		      'ContainedSubtype'=no, 'TypeConstraint'=no,'InnerSubtyping'=no,e=no,'Other'=no}).
 -record(simpletableattributes,{objectsetname,c_name,c_index,usedclassfield,
@@ -73,9 +73,28 @@
 % Externalvaluereference -> modulename '.' typename
 -record('Externalvaluereference',{pos,module,value}).
 
--record(state,{module,mname,type,tname,value,vname,erule,parameters=[],
-	       inputmodules,abscomppath=[],recordtopname=[],options,
-	       sourcedir}).
+%% Used to hold a tag for a field in a SEQUENCE/SET. It can also
+%% be used for identifiers in OBJECT IDENTIFIER values, since the
+%% parser cannot always distinguish a SEQUENCE with one element from
+%% an OBJECT IDENTIFIER.
+-record(seqtag,
+	{pos :: integer(),
+	 module :: atom(),
+	 val :: atom()}).
+
+-record(state,
+	{module,
+	 mname,
+	 tname,
+	 erule,
+	 parameters=[],
+	 inputmodules=[],
+	 abscomppath=[],
+	 recordtopname=[],
+	 options,
+	 sourcedir,
+	 error_context				%Top-level thingie (contains line numbers)
+	}).
 
 %% state record used by back-end at partial decode
 %% active is set to 'yes' when a partial decode function is generated.
diff --git a/lib/asn1/src/asn1ct.erl b/lib/asn1/src/asn1ct.erl
index 8e71a5697c..dd269f095d 100644
--- a/lib/asn1/src/asn1ct.erl
+++ b/lib/asn1/src/asn1ct.erl
@@ -2,23 +2,28 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
 %%
 -module(asn1ct).
+-deprecated([decode/3,encode/3]).
+-compile([{nowarn_deprecated_function,{asn1rt,decode,3}},
+	  {nowarn_deprecated_function,{asn1rt,encode,2}},
+	  {nowarn_deprecated_function,{asn1rt,encode,3}}]).
 
 %% Compile Time functions for ASN.1 (e.g ASN.1 compiler).
 
@@ -30,7 +35,8 @@
 %% Application internal exports
 -export([compile_asn/3,compile_asn1/3,compile_py/3,compile/3,
 	 vsn/0,
-	 get_name_of_def/1,get_pos_of_def/1]).
+	 get_name_of_def/1,get_pos_of_def/1,
+	 unset_pos_mod/1]).
 -export([read_config_data/1,get_gen_state_field/1,
 	 partial_inc_dec_toptype/1,update_gen_state/2,
 	 get_tobe_refed_func/1,reset_gen_state/0,is_function_generated/1,
@@ -39,8 +45,8 @@
 	 add_tobe_refed_func/1,add_generated_refed_func/1,
 	 maybe_rename_function/3,current_sindex/0,
 	 set_current_sindex/1,maybe_saved_sindex/2,
-	 parse_and_save/2,verbose/3,warning/3,warning/4,error/3]).
--export([get_bit_string_format/0]).
+	 parse_and_save/2,verbose/3,warning/3,warning/4,error/3,format_error/1]).
+-export([get_bit_string_format/0,use_legacy_types/0]).
 
 -include("asn1_records.hrl").
 -include_lib("stdlib/include/erl_compile.hrl").
@@ -139,7 +145,8 @@ parse_and_save_passes() ->
      {pass,save,fun save_pass/1}].
 
 common_passes() ->
-    [{pass,check,fun check_pass/1},
+    [{iff,parse,{pass,parse_listing,fun parse_listing/1}},
+     {pass,check,fun check_pass/1},
      {iff,abs,{pass,abs_listing,fun abs_listing/1}},
      {pass,generate,fun generate_pass/1},
      {unless,noobj,{pass,compile,fun compile_pass/1}}].
@@ -161,46 +168,26 @@ set_scan_parse_pass(#st{files=Files}=St) ->
 	    {error,St#st{error=Error}}
     end.
 
-set_scan_parse_pass_1([F|Fs], St) ->
+set_scan_parse_pass_1([F|Fs], #st{file=File}=St) ->
     case asn1ct_tok:file(F) of
 	{error,Error} ->
 	    throw(Error);
 	Tokens when is_list(Tokens) ->
-	    case catch asn1ct_parser2:parse(Tokens) of
+	    case asn1ct_parser2:parse(File, Tokens) of
 		{ok,M} ->
 		    [M|set_scan_parse_pass_1(Fs, St)];
-		{error,ErrorTerm} ->
-		    throw(handle_parse_error(ErrorTerm, St))
+		{error,Errors} ->
+		    throw(Errors)
 	    end
     end;
 set_scan_parse_pass_1([], _) -> [].
 
-parse_pass(#st{code=Tokens}=St) ->
-    case catch asn1ct_parser2:parse(Tokens) of
+parse_pass(#st{file=File,code=Tokens}=St) ->
+    case asn1ct_parser2:parse(File, Tokens) of
 	{ok,M} ->
 	    {ok,St#st{code=M}};
-	{error,ErrorTerm} ->
-	    {error,St#st{error=handle_parse_error(ErrorTerm, St)}}
-    end.
-
-handle_parse_error(ErrorTerm, #st{file=File,opts=Opts}) ->
-    case ErrorTerm of
-	{{Line,_Mod,Message},_TokTup} ->
-	    if
-		is_integer(Line) ->
-		    BaseName = filename:basename(File),
-		    error("syntax error at line ~p in module ~s:~n",
-			  [Line,BaseName], Opts);
-		true ->
-		    error("syntax error in module ~p:~n",
-			  [File], Opts)
-	    end,
-	    print_error_message(Message),
-	    Message;
-	{Line,_Mod,[Message,Token]} ->
-	    error("syntax error: ~p ~p at line ~p~n",
-		  [Message,Token,Line], Opts),
-	    {Line,[Message,Token]}
+	{error,Errors} ->
+	    {error,St#st{error=Errors}}
     end.
 
 merge_pass(#st{file=Base,code=Code}=St) ->
@@ -239,6 +226,16 @@ save_pass(#st{code=M,erule=Erule,dbfile=DbFile}=St) ->
     asn1_db:dbsave(DbFile,M#module.name),
     {ok,St}.
 
+parse_listing(#st{code=Code,outfile=OutFile0}=St) ->
+    OutFile = OutFile0 ++ ".parse",
+    case file:write_file(OutFile, io_lib:format("~p\n", [Code])) of
+	ok ->
+	    done;
+	{error,Reason} ->
+	    Error = {write_error,OutFile,Reason},
+	    {error,St#st{error=[{structured_error,{OutFile0,none},?MODULE,Error}]}}
+    end.
+
 abs_listing(#st{code={M,_},outfile=OutFile}) ->
     pretty2(M#module.name, OutFile++".abs"),
     done.
@@ -333,8 +330,7 @@ print_structured_errors([_|_]=Errors) ->
 print_structured_errors(_) -> ok.
 
 compile1(File, #st{opts=Opts}=St0) ->
-    verbose("Erlang ASN.1 version ~p, compiling ~p~n", [?vsn,File], Opts),
-    verbose("Compiler Options: ~p~n", [Opts], Opts),
+    compiler_verbose(File, Opts),
     Passes = single_passes(),
     Base = filename:rootname(filename:basename(File)),
     OutFile = outfile(Base, "", Opts),
@@ -349,8 +345,7 @@ compile1(File, #st{opts=Opts}=St0) ->
 %% compile_set/3 merges and compiles a number of asn1 modules
 %% specified in a .set.asn file to one .erl file.
 compile_set(SetBase, Files, #st{opts=Opts}=St0) ->
-    verbose("Erlang ASN.1 version ~p compiling ~p ~n", [?vsn,Files], Opts),
-    verbose("Compiler Options: ~p~n",[Opts], Opts),
+    compiler_verbose(Files, Opts),
     OutFile = outfile(SetBase, "", Opts),
     DbFile = outfile(SetBase, "asn1db", Opts),
     InputModules = [begin
@@ -363,6 +358,11 @@ compile_set(SetBase, Files, #st{opts=Opts}=St0) ->
     Passes = set_passes(),
     run_passes(Passes, St).
 
+compiler_verbose(What, Opts) ->
+    verbose("Erlang ASN.1 compiler ~s\n", [?vsn], Opts),
+    verbose("Compiling: ~p\n", [What], Opts),
+    verbose("Options: ~p\n", [Opts], Opts).
+
 %% merge_modules/2 -> returns a module record where the typeorval lists are merged,
 %% the exports lists are merged, the imports lists are merged when the 
 %% elements come from other modules than the merge set, the tagdefault 
@@ -541,7 +541,10 @@ unset_pos_mod(Def) when is_record(Def,pvaluesetdef) ->
 unset_pos_mod(Def) when is_record(Def,pobjectdef) ->
     Def#pobjectdef{pos=undefined};
 unset_pos_mod(Def) when is_record(Def,pobjectsetdef) ->
-    Def#pobjectsetdef{pos=undefined}.
+    Def#pobjectsetdef{pos=undefined};
+unset_pos_mod(#'ComponentType'{} = Def) ->
+    Def#'ComponentType'{pos=undefined};
+unset_pos_mod(Def) -> Def.
 
 get_pos_of_def(#typedef{pos=Pos}) ->
     Pos;
@@ -559,6 +562,8 @@ get_pos_of_def(#pobjectdef{pos=Pos}) ->
     Pos;
 get_pos_of_def(#pobjectsetdef{pos=Pos}) ->
     Pos;
+get_pos_of_def(#'Externaltypereference'{pos=Pos}) ->
+    Pos;
 get_pos_of_def(#'Externalvaluereference'{pos=Pos}) ->
     Pos;
 get_pos_of_def(_) -> 
@@ -838,6 +843,7 @@ delete_double_of_symbol1([],Acc) ->
 generate({M,GenTOrV}, OutFile, EncodingRule, Options) ->
     debug_on(Options),
     setup_bit_string_format(Options),
+    setup_legacy_erlang_types(Options),
     put(encoding_options,Options),
     asn1ct_table:new(check_functions),
 
@@ -866,6 +872,31 @@ generate({M,GenTOrV}, OutFile, EncodingRule, Options) ->
     asn1ct_table:delete(check_functions),
     Result.
 
+setup_legacy_erlang_types(Opts) ->
+    F = case lists:member(legacy_erlang_types, Opts) of
+	    false ->
+		case get_bit_string_format() of
+		    bitstring ->
+			false;
+		    compact ->
+			legacy_forced_info(compact_bit_string),
+			true;
+		    legacy ->
+			legacy_forced_info(legacy_bit_string),
+			true
+		end;
+	    true ->
+		true
+	end,
+    put(use_legacy_erlang_types, F).
+
+legacy_forced_info(Opt) ->
+    io:format("Info: The option 'legacy_erlang_types' "
+	      "is implied by the '~s' option.\n", [Opt]).
+
+use_legacy_types() ->
+    get(use_legacy_erlang_types).
+
 setup_bit_string_format(Opts) ->
     Format = case {lists:member(compact_bit_string, Opts),
 		   lists:member(legacy_bit_string, Opts)} of
@@ -893,17 +924,23 @@ parse_and_save(Module,S) ->
     Options = S#state.options,
     SourceDir = S#state.sourcedir,
     Includes = [I || {i,I} <- Options],
+    Erule = S#state.erule,
     case get_input_file(Module, [SourceDir|Includes]) of
 	%% search for asn1 source
 	{file,SuffixedASN1source} ->
-	    case dbfile_uptodate(SuffixedASN1source,Options) of
-		false ->
-		    parse_and_save1(S, SuffixedASN1source, Options);
-		_ -> ok
+	    Mtime = filelib:last_modified(SuffixedASN1source),
+	    case asn1_db:dbload(Module, Erule, Mtime) of
+		ok -> ok;
+		error -> parse_and_save1(S, SuffixedASN1source, Options)
 	    end;
 	Err ->
-	    warning("could not do a consistency check of the ~p file: no asn1 source file was found.~n",
-		    [lists:concat([Module,".asn1db"])],Options),
+	    case asn1_db:dbload(Module) of
+		ok ->
+		    warning("could not do a consistency check of the ~p file: no asn1 source file was found.~n",
+			    [lists:concat([Module,".asn1db"])],Options);
+		error ->
+		    ok
+	    end,
 	    {error,{asn1,input_file_error,Err}}
     end.
 
@@ -929,48 +966,6 @@ get_input_file(Module,[I|Includes]) ->
 	    get_input_file(Module,Includes)
     end.
 
-dbfile_uptodate(File,Options) ->
-    EncodingRule = get_rule(Options),
-    Ext = filename:extension(File),
-    Base = filename:basename(File,Ext),
-    DbFile = outfile(Base,"asn1db",Options),
-    case file:read_file_info(DbFile) of
-	{error,enoent} ->
-	    false;
-	{ok,FileInfoDb} ->
-	    %% file exists, check date and finally encodingrule
-	    {ok,FileInfoAsn} = file:read_file_info(File),
-	    case FileInfoDb#file_info.mtime < FileInfoAsn#file_info.mtime of
-		true ->
-		    %% date of asn1 spec newer than db file
-		    false;
-		_ -> 
-		    %% date ok,check that same erule was used
-		    Obase = case lists:keysearch(outdir, 1, Options) of
-				{value, {outdir, Odir}} -> 
-				    Odir;
-				_NotFound -> ""
-			    end,
-		    BeamFileName = outfile(Base,"beam",Options),
-		    case file:read_file_info(BeamFileName) of
-			{ok,_} ->
-			    code:add_path(Obase),
-			    BeamFile = list_to_atom(Base),
-			    BeamInfo = (catch BeamFile:info()),
-			    case catch lists:keysearch(options,1,BeamInfo) of
-				{value,{options,OldOptions}} ->
-				    case get_rule(OldOptions) of
-					EncodingRule -> true;
-					_ -> false
-				    end;
-				_ -> false
-			    end;
-			_ -> false
-		    end
-	    end
-    end.
-
-
 input_file_type(Name,I) ->
    case input_file_type(Name) of
        {error,_} -> input_file_type2(filename:basename(Name),I);
@@ -1047,7 +1042,7 @@ get_file_list1(Stream,Dir,Includes,Acc) ->
     Ret = io:get_line(Stream,''),
     case Ret of
 	eof ->
-	    file:close(Stream),
+	    ok = file:close(Stream),
 	    lists:reverse(Acc);
 	FileName ->
 	    SuffixedNameList =
@@ -1108,6 +1103,7 @@ remove_asn_flags(Options) ->
 	  X /= optimize,
 	  X /= compact_bit_string,
 	  X /= legacy_bit_string,
+	  X /= legacy_erlang_types,
 	  X /= debug,
 	  X /= asn1config,
 	  X /= record_name_prefix].
@@ -1374,10 +1370,11 @@ get_value(Module, Type) ->
     end.
 
 check(Module, Includes) ->
-    case asn1_db:dbget(Module,'MODULE') of
-        undefined ->
-            {error, {file_not_found, lists:concat([Module, ".asn1db"])}};
-        M ->
+    case asn1_db:dbload(Module) of
+	error ->
+            {error,asn1db_missing_or_out_of_date};
+	ok ->
+	    M = asn1_db:dbget(Module, 'MODULE'),
             TypeOrVal =  M#module.typeorval,
             State = #state{mname = M#module.name,
                            module = M#module{typeorval=[]},
@@ -1394,33 +1391,6 @@ prepare_bytes(Bytes) -> list_to_binary(Bytes).
 vsn() ->
     ?vsn.
 
-
-
-print_error_message([got,H|T]) when is_list(H) ->
-    io:format(" got:"),
-    print_listing(H,"and"),
-    print_error_message(T);
-print_error_message([expected,H|T]) when is_list(H) ->
-    io:format(" expected one of:"),
-    print_listing(H,"or"),
-    print_error_message(T);
-print_error_message([H|T])  ->
-    io:format(" ~p",[H]),
-    print_error_message(T);
-print_error_message([]) ->
-    io:format("~n").
-
-print_listing([H1,H2|[]],AndOr) ->
-    io:format(" ~p ~s ~p",[H1,AndOr,H2]);
-print_listing([H1,H2|T],AndOr) ->
-    io:format(" ~p,",[H1]),
-    print_listing([H2|T],AndOr);
-print_listing([H],_AndOr) ->
-    io:format(" ~p",[H]);
-print_listing([],_) ->
-    ok.
-
-
 specialized_decode_prepare(Erule,M,TsAndVs,Options) ->
     case lists:member(asn1config,Options) of
 	true ->
@@ -1931,8 +1901,9 @@ read_config_file(ModuleName) ->
 	    Includes = [I || {i,I} <- Options],
 	    read_config_file1(ModuleName,Includes);
 	{error,Reason} ->
-	    file:format_error(Reason),
-	    throw({error,{"error reading asn1 config file",Reason}})
+	    Error = "error reading asn1 config file: " ++
+		file:format_error(Reason),
+	    throw({error,Error})
     end.
 read_config_file1(ModuleName,[]) ->
     case filename:extension(ModuleName) of
@@ -1950,8 +1921,9 @@ read_config_file1(ModuleName,[H|T]) ->
 	{error,enoent} ->
 	    read_config_file1(ModuleName,T);
 	{error,Reason} ->
-	    file:format_error(Reason),
-	    throw({error,{"error reading asn1 config file",Reason}})
+	    Error = "error reading asn1 config file: " ++
+		file:format_error(Reason),
+	    throw({error,Error})
     end.
     
 get_config_info(CfgList,InfoType) ->
@@ -2427,6 +2399,10 @@ verbose(Format, Args, S) ->
 	    ok
     end.
 
+format_error({write_error,File,Reason}) ->
+    io_lib:format("writing output file ~s failed: ~s",
+		  [File,file:format_error(Reason)]).
+
 is_error(S) when is_record(S, state) ->
     is_error(S#state.options);
 is_error(O) ->
diff --git a/lib/asn1/src/asn1ct_check.erl b/lib/asn1/src/asn1ct_check.erl
index f94550b0a4..f2c895bfaa 100644
--- a/lib/asn1/src/asn1ct_check.erl
+++ b/lib/asn1/src/asn1ct_check.erl
@@ -2,18 +2,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -23,8 +24,6 @@
 %% Main Module for ASN.1 compile time functions
 
 %-compile(export_all).
-%% Avoid warning for local function error/1 clashing with autoimported BIF.
--compile({no_auto_import,[error/1]}).
 -export([check/2,storeindb/2,format_error/1]).
 %-define(debug,1).
 -include("asn1_records.hrl").
@@ -60,17 +59,9 @@
 -define(N_BMPString, 30).
 
 -define(TAG_PRIMITIVE(Num),
-	case S#state.erule of
-	    ber ->
-		#tag{class='UNIVERSAL',number=Num,type='IMPLICIT',form=0};
-	    _ -> []
-	end).
+	#tag{class='UNIVERSAL',number=Num,type='IMPLICIT',form=0}).
 -define(TAG_CONSTRUCTED(Num),
-	case S#state.erule of
-	    ber ->
-		#tag{class='UNIVERSAL',number=Num,type='IMPLICIT',form=32};
-	    _ -> []
-	end).
+	#tag{class='UNIVERSAL',number=Num,type='IMPLICIT',form=32}).
 
 -record(newt,{type=unchanged,tag=unchanged,constraint=unchanged,inlined=no}). % used in check_type to update type and tag
  
@@ -91,7 +82,7 @@ check(S,{Types,Values,ParameterizedTypes,Classes,Objects,ObjectSets}) ->
     save_asn1db_uptodate(S,S#state.erule,S#state.mname),
     put(top_module,S#state.mname),
 
-    _ = checkp(S, ParameterizedTypes), %must do this before the templates are used
+    ParamError = checkp(S, ParameterizedTypes), %must do this before the templates are used
     
     %% table to save instances of parameterized objects,object sets
     asn1ct_table:new(parameterized_objects),
@@ -160,8 +151,10 @@ check(S,{Types,Values,ParameterizedTypes,Classes,Objects,ObjectSets}) ->
     Exporterror = check_exports(S,S#state.module),
     ImportError = check_imports(S,S#state.module),
 
-    case {Terror3,Verror5,Cerror,Oerror,Exporterror,ImportError} of
-	{[],[],[],[],[],[]} -> 
+    AllErrors = lists:flatten([ParamError,Terror3,Verror5,Cerror,
+			       Oerror,Exporterror,ImportError]),
+    case AllErrors of
+	[] ->
 	    ContextSwitchTs = context_switch_in_spec(),
 	    InstanceOf = instance_of_in_spec(S#state.mname),
 	    NewTypes = lists:subtract(Types,AddClasses) ++ ContextSwitchTs
@@ -175,8 +168,7 @@ check(S,{Types,Values,ParameterizedTypes,Classes,Objects,ObjectSets}) ->
 	      lists:subtract(NewObjects,ExclO)++InlinedObjects,
 	      lists:subtract(NewObjectSets,ExclOS)++ParObjectSetNames}};
 	_ ->
-	    {error,lists:flatten([Terror3,Verror5,Cerror,
-				  Oerror,Exporterror,ImportError])}
+	    {error,AllErrors}
     end.
 
 context_switch_in_spec() ->
@@ -248,96 +240,37 @@ check_exports(S,Module = #module{}) ->
 	{exports,all} ->
 	    [];
 	{exports,ExportList} when is_list(ExportList) ->
-	    IsNotDefined = 
+	    IsNotDefined =
 		fun(X) ->
-			case catch get_referenced_type(S,X) of
-			    {error,{asn1,_}} ->
-				true;
-			    _ -> false
+			try
+			    _ = get_referenced_type(S,X),
+			    false
+			catch {error,_} ->
+				true
 			end
 		end,
-	    case lists:filter(IsNotDefined,ExportList) of
-		[] ->
-		    [];
-		NoDefExp ->
-		    GetName =
-			fun(T = #'Externaltypereference'{type=N})-> 
-				%%{exported,undefined,entity,N} 
-				NewS=S#state{type=T,tname=N},
-				error({export,"exported undefined entity",NewS})
-			end,
-		    lists:map(GetName,NoDefExp)
-	    end
+	    [return_asn1_error(S, Ext, {undefined_export, Undef}) ||
+		Ext = #'Externaltypereference'{type=Undef} <- ExportList,
+		IsNotDefined(Ext)]
     end.
 
-check_imports(S,Module = #module{ }) ->
-    case Module#module.imports of
-	{imports,[]} ->
-	    [];
-	{imports,ImportList} when is_list(ImportList) ->
-	    check_imports2(S,ImportList,[]);
-	_ ->
-	    []
-    end.
-check_imports2(_S,[],Acc) ->
+check_imports(S, #module{imports={imports,Imports}}) ->
+    check_imports_1(S, Imports, []).
+
+check_imports_1(_S, [], Acc) ->
     Acc;
-check_imports2(S,[#'SymbolsFromModule'{symbols=Imports,module=ModuleRef}|SFMs],Acc) ->
-    NameOfDef =
-	fun(#'Externaltypereference'{type=N}) -> N;
-	   (#'Externalvaluereference'{value=N}) -> N
-	end,
-    Module = NameOfDef(ModuleRef),
-    Refs = [{M,R}||{{M,_},R} <- [{catch get_referenced_type(S,Ref),Ref}||Ref <- Imports]],
-    {Illegal,Other} = lists:splitwith(fun({error,_}) -> true;(_) -> false end,
-				      Refs),
-    ChainedRefs = [R||{M,R} <- Other, M =/= Module],
-    IllegalRefs = [R||{error,R} <- Illegal] ++ 
-	[R||{M,R} <- ChainedRefs, 
-	    ok =/= chained_import(S,Module,M,NameOfDef(R))],
-    ReportError =
-	fun(Ref) ->
-		NewS=S#state{type=Ref,tname=NameOfDef(Ref)},
-		error({import,"imported undefined entity",NewS})
-	end,
-    check_imports2(S,SFMs,[ReportError(Err)||Err <- IllegalRefs]++Acc).
-
-chained_import(S,ImpMod,DefMod,Name) ->
-    %% Name is a referenced structure that is not defined in ImpMod,
-    %% but must be present in the Imports list of ImpMod. The chain of
-    %% imports of Name must end in DefMod.
-    NameOfDef =
-	fun(#'Externaltypereference'{type=N}) -> N;
-	   (#'Externalvaluereference'{value=N}) -> N;
-	   (Other) -> Other
-	end,
-    GetImports =
-	fun(_M_) ->
-		case asn1_db:dbget(_M_,'MODULE') of
-		    #module{imports={imports,ImportList}} ->
-			ImportList;
-		    _ -> []
-		end
-	end,
-    FindNameInImports =
-	fun([],N,_) -> {no_mod,N};
-	   ([#'SymbolsFromModule'{symbols=Imports,module=ModuleRef}|SFMs],N,F) ->
-		case [NameOfDef(X)||X <- Imports, NameOfDef(X) =:= N] of
-		    [] -> F(SFMs,N,F);
-		    [N] -> {NameOfDef(ModuleRef),N}
-		end
-	end,
-    case GetImports(ImpMod) of
-	[] ->
-	    error;
-	Imps ->
-	    case FindNameInImports(Imps,Name,FindNameInImports) of
-		{no_mod,_} ->
-		    error;
-		{DefMod,_} -> ok;
-		{OtherMod,_} ->
-		    chained_import(S,OtherMod,DefMod,Name)
-	    end
-    end.
+check_imports_1(S, [#'SymbolsFromModule'{symbols=Imports,module=ModuleRef}|SFMs], Acc) ->
+    Module = name_of_def(ModuleRef),
+    Refs = [{try get_referenced_type(S, Ref)
+	     catch throw:Error -> Error end,
+	     Ref}
+	    || Ref <- Imports],
+    CreateError = fun(Ref) ->
+			  Error = {undefined_import,name_of_def(Ref),Module},
+			  return_asn1_error(S, Ref, Error)
+		  end,
+    Errors = [CreateError(Ref) || {{error, _}, Ref} <- Refs],
+    check_imports_1(S, SFMs, Errors ++ Acc).
 
 checkt(S0, Names) ->
     Check = fun do_checkt/3,
@@ -350,7 +283,7 @@ checkt(S0, Names) ->
     check_fold(S0, lists:reverse(CtxtSwitch), Check) ++ Types.
 
 do_checkt(S, Name, #typedef{typespec=TypeSpec}=Type0) ->
-    NewS = S#state{type=Type0,tname=Name},
+    NewS = S#state{tname=Name},
     try check_type(NewS, Type0, TypeSpec) of
 	#type{}=Ts ->
 	    case Type0#typedef.checked of
@@ -365,7 +298,7 @@ do_checkt(S, Name, #typedef{typespec=TypeSpec}=Type0) ->
 	    end
     catch
 	{error,Reason} ->
-	    error({type,Reason,NewS});
+	    Reason;
 	{asn1_class,_ClassDef} ->
 	    {asn1_class,Name};
 	pobjectsetdef ->
@@ -399,33 +332,32 @@ do_checkv(S, Name, Value)
        is_record(Value, typedef); %Value set may be parsed as object set.
        is_record(Value, pvaluedef);
        is_record(Value, pvaluesetdef) ->
-    NewS = S#state{value=Value},
-    try check_value(NewS, Value) of
+    try check_value(S, Value) of
 	{valueset,VSet} ->
 	    Pos = asn1ct:get_pos_of_def(Value),
 	    CheckedVSDef = #typedef{checked=true,pos=Pos,
 				    name=Name,typespec=VSet},
-	    asn1_db:dbput(NewS#state.mname, Name, CheckedVSDef),
+	    asn1_db:dbput(S#state.mname, Name, CheckedVSDef),
 	    {valueset,Name};
 	V ->
 	    %% update the valuedef
-	    asn1_db:dbput(NewS#state.mname, Name, V),
+	    asn1_db:dbput(S#state.mname, Name, V),
 	    ok
     catch
 	{error,Reason} ->
-	    error({value,Reason,NewS});
+	    Reason;
 	{pobjectsetdef} ->
 	    {pobjectsetdef,Name};
 	{objectsetdef} ->
 	    {objectsetdef,Name};
-	{objectdef} ->
+	{asn1_class, _} ->
 	    %% this is an object, save as typedef
 	    #valuedef{checked=C,pos=Pos,name=N,type=Type,
 		      value=Def} = Value,
 	    ClassName = Type#type.def,
 	    NewSpec = #'Object'{classname=ClassName,def=Def},
 	    NewDef = #typedef{checked=C,pos=Pos,name=N,typespec=NewSpec},
-	    asn1_db:dbput(NewS#state.mname, Name, NewDef),
+	    asn1_db:dbput(S#state.mname, Name, NewDef),
 	    {objectdef,Name}
     end.
 
@@ -434,7 +366,7 @@ checkp(S, Names) ->
     check_fold(S, Names, fun do_checkp/3).
 
 do_checkp(S0, Name, #ptypedef{typespec=TypeSpec}=Type0) ->
-    S = S0#state{type=Type0,tname=Name},
+    S = S0#state{tname=Name},
     try check_ptype(S, Type0, TypeSpec) of
 	#type{}=Ts ->
 	    Type = Type0#ptypedef{checked=true,typespec=Ts},
@@ -442,7 +374,7 @@ do_checkp(S0, Name, #ptypedef{typespec=TypeSpec}=Type0) ->
 	    ok
     catch
 	{error,Reason} ->
-	    error({type,Reason,S});
+	    Reason;
 	{asn1_class,_ClassDef} ->
 	    {asn1_class,Name};
 	{asn1_param_class,_} ->
@@ -453,100 +385,81 @@ do_checkp(S0, Name, #ptypedef{typespec=TypeSpec}=Type0) ->
 checkc(S, Names) ->
     check_fold(S, Names, fun do_checkc/3).
 
-do_checkc(S0, Name, Class0) ->
-    {Class1,ClassSpec} =
-	case Class0 of
-	    #classdef{} ->
-		{Class0,Class0};
-	    #typedef{} ->
-		{#classdef{name=Name},Class0#typedef.typespec}
-	end,
-    S = S0#state{type=Class0,tname=Name},
-    try check_class(S, ClassSpec) of
-	C ->
-	    Class = Class1#classdef{checked=true,typespec=C},
-	    asn1_db:dbput(S#state.mname, Name, Class),
-	    ok
-	 catch
-	     {error,Reason} ->
-		 error({class,Reason,S})
-	 end.
+do_checkc(S, Name, Class) ->
+    try
+	case is_classname(Name) of
+	    false ->
+		asn1_error(S, {illegal_class_name,Name});
+	    true ->
+		do_checkc_1(S, Name, Class)
+	end
+    catch {error,Reason} -> Reason
+    end.
+
+do_checkc_1(S, Name, #classdef{}=Class) ->
+    C = check_class(S, Class),
+    store_class(S, true, Class#classdef{typespec=C}, Name),
+    ok;
+do_checkc_1(S, Name, #typedef{typespec=#type{def=Def}=TS}) ->
+    C = check_class(S, TS),
+    {Mod,Pos} = case Def of
+		    #'Externaltypereference'{module=M, pos=P} ->
+			{M,P};
+		    {pt, #'Externaltypereference'{module=M, pos=P}, _} ->
+			{M,P}
+		end,
+    Class = #classdef{name=Name, typespec=C, pos=Pos, module=Mod},
+    store_class(S, true, Class, Name),
+    ok.
+
+%% is_classname(Atom) -> true|false.
+is_classname(Name) when is_atom(Name) ->
+    lists:all(fun($-) -> true;
+		 (D) when $0 =< D, D =< $9 -> true;
+		 (UC) when $A =< UC, UC =< $Z -> true;
+		 (_) -> false
+	      end, atom_to_list(Name)).
     
-checko(S,[Name|Os],Acc,ExclO,ExclOS) ->
-    ?dbg("Checking object ~p~n",[Name]),
-    Result = 
-	case asn1_db:dbget(S#state.mname,Name) of
-	    undefined ->
-		error({type,{internal_error,'???'},S});
-	    Object when is_record(Object,typedef) ->
-		NewS = S#state{type=Object,tname=Name},
-		case catch(check_object(NewS,Object,Object#typedef.typespec)) of
-		    {error,Reason} ->
-			error({type,Reason,NewS});
-		    {'EXIT',Reason} ->
-			error({type,{internal_error,Reason},NewS});
-		    {asn1,Reason} ->
-			error({type,Reason,NewS});
-		    O ->
-			NewObj = Object#typedef{checked=true,typespec=O},
-			asn1_db:dbput(NewS#state.mname,Name,NewObj),
-			if
-			    is_record(O,'Object') ->
-				case O#'Object'.gen of
-				    true ->
-					{ok,ExclO,ExclOS};
-				    false ->
-					{ok,[Name|ExclO],ExclOS}
-				end;
-			    is_record(O,'ObjectSet') ->
-				case O#'ObjectSet'.gen of
-				    true ->
-					{ok,ExclO,ExclOS};
-				    false ->
-					{ok,ExclO,[Name|ExclOS]}
-				end
-			end
-		end;
-	    PObject when is_record(PObject,pobjectdef) ->
-		NewS = S#state{type=PObject,tname=Name},
-		case (catch check_pobject(NewS,PObject)) of
-		    {error,Reason} ->
-			error({type,Reason,NewS});
-		    {'EXIT',Reason} ->
-			error({type,{internal_error,Reason},NewS});
-		    {asn1,Reason} ->
-			error({type,Reason,NewS});
-		    PO ->
-			NewPObj = PObject#pobjectdef{def=PO},
-			asn1_db:dbput(NewS#state.mname,Name,NewPObj),
-			{ok,[Name|ExclO],ExclOS}
-		end;
-	    PObjSet when is_record(PObjSet,pvaluesetdef) ->
-		%% this is a parameterized object set. Might be a parameterized
-		%% value set, couldn't it?
-		NewS = S#state{type=PObjSet,tname=Name},
-		case (catch check_pobjectset(NewS,PObjSet)) of
-		    {error,Reason} ->
-			error({type,Reason,NewS});
-		    {'EXIT',Reason} ->
-			error({type,{internal_error,Reason},NewS});
-		    {asn1,Reason} ->
-			error({type,Reason,NewS});
-		    POS ->
-			%%NewPObjSet = PObjSet#pvaluesetdef{valueset=POS},
-			asn1_db:dbput(NewS#state.mname,Name,POS),
-			{ok,ExclO,[Name|ExclOS]}
-		end
-	end,
-    case Result of
-	{ok,NewExclO,NewExclOS} ->
-	    checko(S,Os,Acc,NewExclO,NewExclOS);
-	_ ->
-	    checko(S,Os,[Result|Acc],ExclO,ExclOS)
+checko(S0,[Name|Os],Acc,ExclO,ExclOS) ->
+    Item = asn1_db:dbget(S0#state.mname, Name),
+    S = S0#state{error_context=Item},
+    try checko_1(S, Item, Name, ExclO, ExclOS) of
+	{NewExclO,NewExclOS} ->
+	    checko(S, Os, Acc, NewExclO, NewExclOS)
+    catch
+	throw:{error, Error} ->
+	    checko(S, Os, [Error|Acc], ExclO, ExclOS)
     end;
 checko(_S,[],Acc,ExclO,ExclOS) ->
     {lists:reverse(Acc),lists:reverse(ExclO),lists:reverse(ExclOS)}.
 
+checko_1(S, #typedef{typespec=TS}=Object, Name, ExclO, ExclOS) ->
+    NewS = S#state{tname=Name},
+    O = check_object(NewS, Object, TS),
+    NewObj = Object#typedef{checked=true,typespec=O},
+    asn1_db:dbput(NewS#state.mname, Name, NewObj),
+    case O of
+	#'Object'{gen=true} ->
+	    {ExclO,ExclOS};
+	#'Object'{gen=false} ->
+	    {[Name|ExclO],ExclOS};
+	#'ObjectSet'{gen=true} ->
+	    {ExclO,ExclOS};
+	#'ObjectSet'{gen=false} ->
+	    {ExclO,[Name|ExclOS]}
+    end;
+checko_1(S, #pobjectdef{}=PObject, Name, ExclO, ExclOS) ->
+    NewS = S#state{tname=Name},
+    PO = check_pobject(NewS, PObject),
+    NewPObj = PObject#pobjectdef{def=PO},
+    asn1_db:dbput(NewS#state.mname, Name, NewPObj),
+    {[Name|ExclO],ExclOS};
+checko_1(S, #pvaluesetdef{}=PObjSet, Name, ExclO, ExclOS) ->
+    NewS = S#state{tname=Name},
+    POS = check_pobjectset(NewS, PObjSet),
+    asn1_db:dbput(NewS#state.mname, Name, POS),
+    {ExclO,[Name|ExclOS]}.
+
 check_class(S,CDef=#classdef{checked=Ch,name=Name,typespec=TS}) ->
     case Ch of
 	true -> TS;
@@ -565,27 +478,17 @@ check_class(S = #state{mname=M,tname=T},ClassSpec)
 	    #objectclass{fields=Def}; % in case of recursive definitions
 	Tref = #'Externaltypereference'{type=TName} ->
 	    {MName,RefType} = get_referenced_type(S,Tref),
-	    case is_class(S,RefType) of
-		true ->
-		    NewState = update_state(S#state{type=RefType,
-						    tname=TName},MName),
- 		    check_class(NewState,get_class_def(S,RefType));
-		_ ->
-		    error({class,{internal_error,RefType},S})
-	    end;
+	    #classdef{} = CD = get_class_def(S, RefType),
+	    NewState = update_state(S#state{tname=TName}, MName),
+	    check_class(NewState, CD);
 	{pt,ClassRef,Params} ->
 	    %% parameterized class
 	    {_,PClassDef} = get_referenced_type(S,ClassRef),
-	    NewParaList = 
-		[match_parameters(S,TmpParam,S#state.parameters)|| 
-		    TmpParam <- Params],
+	    NewParaList = match_parameters(S, Params),
 	    instantiate_pclass(S,PClassDef,NewParaList)
     end;
-check_class(S,C) when is_record(C,objectclass) ->
-    NewFieldSpec = check_class_fields(S,C#objectclass.fields),
-    C#objectclass{fields=NewFieldSpec};
-check_class(_S,{poc,_ObjSet,_Params}) ->
-    'fix this later';
+check_class(S, #objectclass{}=C) ->
+    check_objectclass(S, C);
 check_class(S,ClassName) ->
     {RefMod,Def} = get_referenced_type(S,ClassName),
     case Def of
@@ -598,8 +501,7 @@ check_class(S,ClassName) ->
 		false ->
 		    Name=ClassName#'Externaltypereference'.type,
 		    store_class(S,idle,ClassDef,Name),
-%		    NewS = S#state{mname=RefMod,type=Def,tname=Name},
-		    NewS = update_state(S#state{type=Def,tname=Name},RefMod),
+		    NewS = update_state(S#state{tname=Name}, RefMod),
 		    CheckedTS = check_class(NewS,ClassDef#classdef.typespec),
 		    store_class(S,true,ClassDef#classdef{typespec=CheckedTS},Name),
 		    CheckedTS
@@ -613,11 +515,20 @@ check_class(S,ClassName) ->
 	    end
     end.
 
+check_objectclass(S, #objectclass{fields=Fs0,syntax=Syntax0}=C) ->
+    Fs = check_class_fields(S, Fs0),
+    case Syntax0 of
+	{'WITH SYNTAX',Syntax1} ->
+	    Syntax = preprocess_syntax(S, Syntax1, Fs),
+	    C#objectclass{fields=Fs,syntax={preprocessed_syntax,Syntax}};
+	_ ->
+	    C#objectclass{fields=Fs}
+    end.
+
 instantiate_pclass(S=#state{parameters=_OldArgs},PClassDef,Params) ->
     #ptypedef{args=Args,typespec=Type} = PClassDef,
     MatchedArgs = match_args(S,Args, Params, []),
-%    NewS = S#state{type=Type,parameters=MatchedArgs++OldArgs,abscomppath=[]},
-    NewS = S#state{type=Type,parameters=MatchedArgs,abscomppath=[]},
+    NewS = S#state{parameters=MatchedArgs,abscomppath=[]},
     check_class(NewS,#classdef{name=S#state.tname,typespec=Type}).
 
 store_class(S,Mode,ClassDef,ClassName) ->
@@ -632,6 +543,12 @@ check_class_fields(S,[F|Fields],Acc) ->
 	case element(1,F) of
 	    fixedtypevaluefield ->
 		{_,Name,Type,Unique,OSpec} = F,
+		case {Unique,OSpec} of
+		    {'UNIQUE',{'DEFAULT',_}} ->
+			asn1_error(S, {unique_and_default,Name});
+		    {_,_} ->
+			ok
+		end,
 		RefType = check_type(S,#typedef{typespec=Type},Type),
 		{fixedtypevaluefield,Name,RefType,Unique,OSpec};
 	    object_or_fixedtypevalue_field ->
@@ -640,7 +557,7 @@ check_class_fields(S,[F|Fields],Acc) ->
 		Cat = 
 		    case asn1ct_gen:type(asn1ct_gen:get_inner(Type2#type.def)) of
 			Def when is_record(Def,'Externaltypereference') ->
-			    {_,D} = get_referenced_type(S,Def),
+			    {_,D} = get_referenced_type(S, Def, true),
 			    D;
 			{undefined,user} -> 
 			    %% neither of {primitive,bif} or {constructed,bif}
@@ -663,18 +580,14 @@ check_class_fields(S,[F|Fields],Acc) ->
 	    objectset_or_fixedtypevalueset_field ->
 		{_,Name,Type,OSpec} = F,
 		RefType =
-		    case (catch check_type(S,#typedef{typespec=Type},Type)) of
-			{asn1_class,_ClassDef} ->
+		    try check_type(S,#typedef{typespec=Type},Type) of
+			#type{} = CheckedType ->
+			    CheckedType
+		    catch {asn1_class,_ClassDef} ->
 			    case if_current_checked_type(S,Type) of
-				true ->
-				    Type#type.def;
-				_ ->
-				    check_class(S,Type)
-			    end;
-			CheckedType when is_record(CheckedType,type) ->
-			    CheckedType;
-			_ ->
-			    error({class,"internal error, check_class_fields",S})
+				true -> Type#type.def;
+				_ ->    check_class(S,Type)
+			    end
 		    end,
 		if
 		    is_record(RefType,'Externaltypereference') ->
@@ -752,38 +665,34 @@ check_pobjectset(S,PObjSet) ->
 	    PObjSet
     end.
 
+-record(osi,					%Object set information.
+	{st,
+	 classref,
+	 uniq,
+	 ext
+	}).
+
 check_object(_S,ObjDef,ObjSpec) when (ObjDef#typedef.checked == true) ->
     ObjSpec;
 check_object(S,_ObjDef,#'Object'{classname=ClassRef,def=ObjectDef}) ->
     ?dbg("check_object ~p~n",[ObjectDef]),
-%%    io:format("check_object,object: ~p~n",[ObjectDef]),
-%    {MName,_ClassDef} = get_referenced_type(S,ClassRef),
-    NewClassRef = check_externaltypereference(S,ClassRef),
-    ClassDef =
-	case get_referenced_type(S,ClassRef) of
-	    {MName,ClDef=#classdef{checked=false}} ->
-		NewState = update_state(S#state{type=ClDef,
-				   tname=ClassRef#'Externaltypereference'.type},MName),
-		ObjClass= 
-		    check_class(NewState,ClDef),
-		#classdef{checked=true,
-			  typespec=ObjClass};
-	    {_,_ClDef} when is_record(_ClDef,classdef) ->		
-		_ClDef;
-	    {MName,_TDef=#typedef{checked=false,pos=Pos,
-				   name=_TName,typespec=TS}} ->
-		ClDef = #classdef{pos=Pos,name=_TName,typespec=TS},
-		NewState = update_state(S#state{type=_TDef,
-			tname=ClassRef#'Externaltypereference'.type},MName),	   
-		ObjClass =
-		    check_class(NewState,ClDef),
-		ClDef#classdef{checked=true,typespec=ObjClass};
-	    {_,_ClDef} ->
-		_ClDef
+    _ = check_externaltypereference(S,ClassRef),
+    {ClassDef, NewClassRef} =
+	case get_referenced_type(S, ClassRef, true) of
+	    {MName,#classdef{checked=false, name=CLName}=ClDef} ->
+		Type = ClassRef#'Externaltypereference'.type,
+		NewState = update_state(S#state{tname=Type}, MName),
+		ObjClass = check_class(NewState, ClDef),
+		{ClDef#classdef{checked=true, typespec=ObjClass},
+		 #'Externaltypereference'{module=MName, type=CLName}};
+	    {MName,#classdef{name=CLName}=ClDef} ->
+		{ClDef, #'Externaltypereference'{module=MName, type=CLName}};
+	    _ ->
+		asn1_error(S, illegal_object)
 	end,
     NewObj =
 	case ObjectDef of
-	    Def when is_tuple(Def), (element(1,Def)==object) ->
+	    {object,_,_}=Def ->
 		NewSettingList = check_objectdefn(S,Def,ClassDef),
 		#'Object'{def=NewSettingList};
 	    {po,{object,DefObj},ArgsList} ->
@@ -797,423 +706,287 @@ check_object(S,_ObjDef,#'Object'{classname=ClassRef,def=ObjectDef}) ->
 		instantiate_po(S,ClassDef,Object,ArgList);
 	    #'Externalvaluereference'{} ->
 		{_,Object} = get_referenced_type(S,ObjectDef),
-		check_object(S,Object,Object#typedef.typespec);
+		check_object(S, Object, object_to_check(S, Object));
 	    [] -> 
-		%% An object with no fields. All class fields must be
-		%% optional or default.  Check that all fields in
-		%% class are 'OPTIONAL' or 'DEFAULT'
-		class_fields_optional_check(S,ClassDef),
-		#'Object'{def={object,defaultsyntax,[]}};
-	    _  ->
-		exit({error,{no_object,ObjectDef},S})
+		%% An object with no fields (parsed as a value).
+		Def = {object,defaultsyntax,[]},
+		NewSettingList = check_objectdefn(S, Def, ClassDef),
+		#'Object'{def=NewSettingList};
+	    _ ->
+		asn1_error(S, illegal_object)
 	end,
-    Gen = gen_incl(S,NewObj#'Object'.def,
-		   (ClassDef#classdef.typespec)#objectclass.fields),
+    Fields = (ClassDef#classdef.typespec)#objectclass.fields,
+    Gen = gen_incl(S,NewObj#'Object'.def, Fields),
     NewObj#'Object'{classname=NewClassRef,gen=Gen};
-
-
-check_object(S,
-	     _ObjSetDef,
-	     ObjSet=#'ObjectSet'{class=ClassRef}) ->
-%%    io:format("check_object,SET: ~p~n",[ObjSet#'ObjectSet'.set]),
-    ?dbg("check_object set: ~p~n",[ObjSet#'ObjectSet'.set]),
-    {_,ClassDef} = get_referenced_type(S,ClassRef),
-    NewClassRef = check_externaltypereference(S,ClassRef),
-    {UniqueFieldName,UniqueInfo} = 
-	case (catch get_unique_fieldname(S,ClassDef)) of
-	    {error,'__undefined_',_} -> 
-		{{unique,undefined},{unique,undefined}};
-	    {asn1,Msg,_} -> error({class,Msg,S});
-	    {'EXIT',Msg} -> error({class,{internal_error,Msg},S});
+check_object(S, _, #'ObjectSet'{class=ClassRef0,set=Set0}=ObjSet0) ->
+    {_,ClassDef} = get_referenced_type(S, ClassRef0),
+    ClassRef = check_externaltypereference(S, ClassRef0),
+    {UniqueFieldName,UniqueInfo} =
+	case get_unique_fieldname(S, ClassDef) of
+	    no_unique -> {{unique,undefined},{unique,undefined}};
 	    Other -> {element(1,Other),Other}
 	end,
-    NewObjSet=
-	case prepare_objset(ObjSet#'ObjectSet'.set) of
-	    {set,SET,EXT} ->
-		CheckedSet = check_object_list(S,NewClassRef,SET),
-		NewSet = get_unique_valuelist(S,CheckedSet,UniqueInfo),
-		ObjSet#'ObjectSet'{uniquefname=UniqueFieldName,
-				   set=extensionmark(NewSet,EXT)};
-
-	    {'SingleValue',ERef = #'Externalvaluereference'{}} ->
-		{RefedMod,ObjDef} = get_referenced_type(S,ERef),
-		#'Object'{def=CheckedObj} = 
-		    check_object(S,ObjDef,ObjDef#typedef.typespec),
-
-		NewSet = get_unique_valuelist(S,[{{RefedMod,get_datastr_name(ObjDef)},
-						  CheckedObj}],
-					      UniqueInfo),
-		ObjSet#'ObjectSet'{uniquefname=UniqueFieldName,
-				   set=NewSet};
-	    ['EXTENSIONMARK'] ->
-		ObjSet#'ObjectSet'{uniquefname=UniqueFieldName,
-				   set=['EXTENSIONMARK']};
-
-	    OSref when is_record(OSref,'Externaltypereference') ->
-		{_,OS=#typedef{typespec=OSdef}} = get_referenced_type(S,OSref),
-		check_object(S,OS,OSdef);
-
-	    {Type,{'EXCEPT',Exclusion}} when is_record(Type,type) ->
-		{_,TDef} = get_referenced_type(S,Type#type.def),
-		OS = TDef#typedef.typespec,
-		NewSet = reduce_objectset(OS#'ObjectSet'.set,Exclusion),
-		NewOS = OS#'ObjectSet'{set=NewSet},
-		check_object(S,TDef#typedef{typespec=NewOS},
-			     NewOS);
-	    #type{def={pt,DefinedObjSet,ParamList}} ->
-		{_,PObjSetDef} = get_referenced_type(S,DefinedObjSet),
-		NewParamList = 
-		    [match_parameters(S,TmpParam,S#state.parameters)|| 
-			TmpParam <- ParamList],
-		instantiate_pos(S,ClassRef,PObjSetDef,NewParamList);
-
-	    %% actually this is an ObjectSetFromObjects construct, it
-	    %% is when the object set is retrieved from an object
-	    %% field.
-	    #type{def=#'ObjectClassFieldType'{classname=ObjName,
-					      fieldname=FieldName}} ->
-		{RefedObjMod,TDef} = get_referenced_type(S,ObjName),
-		OS=TDef#typedef.typespec,
-		%% should get the right object set here. Get the field
-		%% FieldName out of the object set OS of class
-		%% OS#'ObjectSet'.class
-		OS2=check_object(S,TDef,OS),
-		NewSet=object_set_from_objects(S,RefedObjMod,FieldName,OS2),
-		ObjSet#'ObjectSet'{uniquefname=UniqueFieldName,
-				   set=NewSet};
-	    {'ObjectSetFromObjects',{_,_,ObjName},FieldName} ->
-		{RefedObjMod,TDef} = get_referenced_type(S,ObjName),
-		OS=TDef#typedef.typespec,
-		%% should get the right object set here. Get the field
-		%% FieldName out of the object set OS of class
-		%% OS#'ObjectSet'.class
-		OS2=check_object(S,TDef,OS),
-		NewSet=object_set_from_objects(S,RefedObjMod,FieldName,OS2),
-		ObjSet#'ObjectSet'{uniquefname=UniqueFieldName,
-				   set=NewSet};
-	     {'ObjectSetFromObjects',{_,ObjName},FieldName} ->
-		%% This is a ObjectSetFromObjects, i.e.
-		%% ObjectSetFromObjects ::= ReferencedObjects "." FieldName
-		%% with a defined object as ReferencedObjects. And
-		%% the FieldName of the Class (object) contains an object set.
-		{RefedObjMod,TDef} = get_referenced_type(S,ObjName),
-		O1 = TDef#typedef.typespec,
-		O2 = check_object(S,TDef,O1),
-		NewSet = object_set_from_objects(S,RefedObjMod,FieldName,O2),
-		OS2=ObjSet#'ObjectSet'{uniquefname=UniqueFieldName,
-				   set=NewSet},
-		%%io:format("ObjectSet: ~p~n",[OS2]),
-		OS2;
-	    {pos,{objectset,_,DefinedObjSet},Params} ->
-		{_,PObjSetDef} = get_referenced_type(S,DefinedObjSet),
-		NewParamList = 
-		    [match_parameters(S,TmpParam,S#state.parameters)|| 
-			TmpParam <- Params],
-		instantiate_pos(S,ClassRef,PObjSetDef,NewParamList);
-	    Unknown ->
-		exit({error,{unknown_object_set,Unknown},S})
-	end,
-    NewSet2 = remove_duplicate_objects(NewObjSet#'ObjectSet'.set),
-    NewObjSet2 = NewObjSet#'ObjectSet'{set=NewSet2},
-    Gen = gen_incl_set(S,NewObjSet2#'ObjectSet'.set,
-		       ClassDef),
-    ?dbg("check_object done~n",[]),
-    NewObjSet2#'ObjectSet'{class=NewClassRef,gen=Gen}.
+    OSI0 = #osi{st=S,classref=ClassRef,uniq=UniqueInfo,ext=false},
+    {Set1,OSI1} = if
+		      is_list(Set0) ->
+			  check_object_set_list(Set0, OSI0);
+		      true ->
+			  check_object_set(Set0, OSI0)
+		  end,
+    Ext = case Set1 of
+	      [] ->
+		  %% FIXME: X420 does not compile unless we force
+		  %% empty sets to be extensible. There should be
+		  %% a better way.
+		  true;
+	      [_|_] ->
+		  OSI1#osi.ext
+	  end,
+    Set2 = remove_duplicate_objects(S, Set1),
+    Set = case Ext of
+	      false -> Set2;
+	      true -> Set2 ++ ['EXTENSIONMARK']
+	  end,
+    ObjSet = ObjSet0#'ObjectSet'{uniquefname=UniqueFieldName,set=Set},
+    Gen = gen_incl_set(S, Set, ClassDef),
+    ObjSet#'ObjectSet'{class=ClassRef,gen=Gen}.
+
+check_object_set({element_set,Root0,Ext0}, OSI0) ->
+    OSI = case Ext0 of
+	      none -> OSI0;
+	      _ -> OSI0#osi{ext=true}
+	  end,
+    case {Root0,Ext0} of
+	{empty,empty} -> {[],OSI};
+	{empty,Ext} -> check_object_set(Ext, OSI);
+	{Root,none} -> check_object_set(Root, OSI);
+	{Root,empty} -> check_object_set(Root, OSI);
+	{Root,Ext} -> check_object_set_list([Root,Ext], OSI)
+    end;
+check_object_set(#'Externaltypereference'{}=Ref, #osi{st=S}=OSI) ->
+    {_,#typedef{typespec=OSdef}=OS} = get_referenced_type(S, Ref),
+    ObjectSet = check_object(S, OS, OSdef),
+    check_object_set_objset(ObjectSet, OSI);
+check_object_set(#'Externalvaluereference'{}=Ref, #osi{st=S}=OSI) ->
+    {RefedMod,ObjName,#'Object'{def=Def}} = check_referenced_object(S, Ref),
+    ObjList = check_object_set_mk(RefedMod, ObjName, Def, OSI),
+    {ObjList,OSI};
+check_object_set({'EXCEPT',Incl0,Excl0}, OSI) ->
+    {Incl1,_} = check_object_set(Incl0, OSI),
+    {Excl1,_} = check_object_set(Excl0, OSI),
+    Exclude = sofs:set([N || {N,_} <- Excl1], [name]),
+    Incl2 = [{Name,Obj} || {Name,_,_}=Obj <- Incl1],
+    Incl3 = sofs:relation(Incl2, [{name,object}]),
+    Incl4 = sofs:drestriction(Incl3, Exclude),
+    Incl5 = sofs:to_external(Incl4),
+    Incl = [Obj || {_,Obj} <- Incl5],
+    {Incl,OSI};
+check_object_set({object,_,_}=Obj0, OSI) ->
+    #osi{st=S,classref=ClassRef} = OSI,
+    #'Object'{def=Def} =
+	check_object(S, #typedef{typespec=Obj0},
+		     #'Object'{classname=ClassRef,def=Obj0}),
+    ObjList = check_object_set_mk(Def, OSI),
+    {ObjList,OSI};
+check_object_set(#'ObjectClassFieldType'{classname=ObjName,
+					 fieldname=FieldNames},
+		 #osi{st=S}=OSI) ->
+    Set = check_ObjectSetFromObjects(S, ObjName, FieldNames),
+    check_object_set_objset_list(Set, OSI);
+check_object_set({'ObjectSetFromObjects',Obj,FieldNames}, #osi{st=S}=OSI) ->
+    ObjName = element(tuple_size(Obj), Obj),
+    Set = check_ObjectSetFromObjects(S, ObjName, FieldNames),
+    check_object_set_objset_list(Set, OSI);
+check_object_set({pt,DefinedObjSet,ParamList0}, OSI) ->
+    #osi{st=S,classref=ClassRef} = OSI,
+    {_,PObjSetDef} = get_referenced_type(S, DefinedObjSet),
+    ParamList = match_parameters(S, ParamList0),
+    ObjectSet = instantiate_pos(S, ClassRef, PObjSetDef, ParamList),
+    check_object_set_objset(ObjectSet, OSI);
+check_object_set({pos,{objectset,_,DefinedObjSet},Params0}, OSI) ->
+    #osi{st=S,classref=ClassRef} = OSI,
+    {_,PObjSetDef} = get_referenced_type(S, DefinedObjSet),
+    Params = match_parameters(S, Params0),
+    ObjectSet = instantiate_pos(S, ClassRef, PObjSetDef, Params),
+    check_object_set_objset(ObjectSet, OSI);
+check_object_set({pv,{simpledefinedvalue,DefinedObject},Params}=PV, OSI) ->
+    #osi{st=S,classref=ClassRef} = OSI,
+    Args = match_parameters(S, Params),
+    #'Object'{def=Def} =
+	check_object(S, PV,
+		     #'Object'{classname=ClassRef ,
+			       def={po,{object,DefinedObject},Args}}),
+    ObjList = check_object_set_mk(Def, OSI),
+    {ObjList,OSI};
+check_object_set({'SingleValue',Val}, OSI) ->
+    check_object_set(Val, OSI);
+check_object_set({'ValueFromObject',{object,Object},FieldNames}, OSI) ->
+    #osi{st=S} = OSI,
+    case extract_field(S, Object, FieldNames) of
+	#'Object'{def=Def} ->
+	    ObjList = check_object_set_mk(Def, OSI),
+	    {ObjList,OSI};
+	_ ->
+	    asn1_error(S, illegal_object)
+    end;
+check_object_set(#type{def=Def}, OSI) ->
+    check_object_set(Def, OSI);
+check_object_set({union,A0,B0}, OSI0) ->
+    {A,OSI1} = check_object_set(A0, OSI0),
+    {B,OSI} = check_object_set(B0, OSI1),
+    {A++B,OSI}.
+
+check_object_set_list([H|T], OSI0) ->
+    {Set0,OSI1} = check_object_set(H, OSI0),
+    {Set1,OSI2} = check_object_set_list(T, OSI1),
+    {Set0++Set1,OSI2};
+check_object_set_list([], OSI) ->
+    {[],OSI}.
+
+check_object_set_objset(#'ObjectSet'{set=Set}, OSI) ->
+    check_object_set_objset_list(Set, OSI).
+
+check_object_set_objset_list(Set, OSI) ->
+    check_object_set_objset_list_1(Set, OSI, []).
+
+check_object_set_objset_list_1(['EXTENSIONMARK'|T], OSI, Acc) ->
+    check_object_set_objset_list_1(T, OSI#osi{ext=true}, Acc);
+check_object_set_objset_list_1([H|T], OSI, Acc) ->
+    check_object_set_objset_list_1(T, OSI, [H|Acc]);
+check_object_set_objset_list_1([], OSI, Acc) ->
+    {Acc,OSI}.
+
+check_object_set_mk(Fields, OSI) ->
+    check_object_set_mk(no_mod, no_name, Fields, OSI).
+
+check_object_set_mk(M, N, Def, #osi{uniq={unique,undefined}}) ->
+    {_,_,Fields} = Def,
+    [{{M,N},no_unique_value,Fields}];
+check_object_set_mk(M, N, Def, #osi{uniq={UniqField,_}}) ->
+    {_,_,Fields} = Def,
+    case lists:keyfind(UniqField, 1, Fields) of
+	{UniqField,#valuedef{value=Val}} ->
+	    [{{M,N},Val,Fields}];
+	false ->
+	    case Fields of
+		[{_,#typedef{typespec=#'ObjectSet'{set=['EXTENSIONMARK']}}}] ->
+		    %% FIXME: If object is missing the unique field and
+		    %% only contains a reference to an empty object set,
+		    %% we will remove the entire object as a workaround
+		    %% to get X420 to compile. There should be a better
+		    %% way.
+		    [];
+		_ ->
+		    [{{M,N},no_unique_value,Fields}]
+	    end
+    end.
 
 %% remove_duplicate_objects/1 remove duplicates of objects.
 %% For instance may Set contain objects of same class from
 %% different object sets that in fact might be duplicates.
-remove_duplicate_objects(Set) when is_list(Set) ->
-    Pred = fun({A,B,_},{A,C,_}) when B =< C -> true;
-	      ({A,_,_},{B,_,_}) when A < B -> true;
-	      ('EXTENSIONMARK','EXTENSIONMARK') -> true;
-	      (T,A) when is_tuple(T),is_atom(A) -> true;% EXTENSIONMARK last in list
-	      (_,_) -> false 
-	   end,
-    lists:usort(Pred,Set).
+remove_duplicate_objects(S, Set0) when is_list(Set0) ->
+    Set1 = [{Id,Orig} || {_,Id,_}=Orig <- Set0],
+    Set2 = sofs:relation(Set1),
+    Set3 = sofs:relation_to_family(Set2),
+    Set = sofs:to_external(Set3),
+    remove_duplicate_objects_1(S, Set).
+
+remove_duplicate_objects_1(S, [{no_unique_value,Objs}|T]) ->
+    Objs ++ remove_duplicate_objects_1(S, T);
+remove_duplicate_objects_1(S, [{_,[_]=Objs}|T]) ->
+    Objs ++ remove_duplicate_objects_1(S, T);
+remove_duplicate_objects_1(S, [{Id,[_|_]=Objs}|T]) ->
+    MakeSortable = fun(What) -> sortable_type(S, What) end,
+    Tagged = order_tag_set(Objs, MakeSortable),
+    case lists:ukeysort(1, Tagged) of
+	[{_,Obj}] ->
+	    [Obj|remove_duplicate_objects_1(S, T)];
+	[_|_] ->
+	    asn1_error(S, {non_unique_object,Id})
+    end;
+remove_duplicate_objects_1(_, []) ->
+    [].
 
-%%
-extensionmark(L,true) ->
-    case lists:member('EXTENSIONMARK',L) of
-	true -> L;
-	_ -> L ++ ['EXTENSIONMARK']
+order_tag_set([{_, _, Fields}=Orig|Fs], Fun) ->
+    Pair = {[{FId, traverse(F, Fun)} || {FId, F} <- Fields], Orig},
+    [Pair|order_tag_set(Fs, Fun)];
+order_tag_set([], _) -> [].
+
+sortable_type(S, #'Externaltypereference'{}=ERef) ->
+    try get_referenced_type(S, ERef) of
+	 {_,#typedef{}=OI} ->
+	    OI#typedef{pos=undefined,name=undefined}
+    catch
+	_:_ ->
+	    ERef
     end;
-extensionmark(L,_) ->
-    L.
+sortable_type(_, #typedef{}=TD) ->
+    asn1ct:unset_pos_mod(TD#typedef{name=undefined});
+sortable_type(_, Type) ->
+    asn1ct:unset_pos_mod(Type).
+
+traverse(Structure0, Fun) ->
+    Structure = Fun(Structure0),
+    traverse_1(Structure, Fun).
+
+traverse_1(#typedef{typespec=TS0} = TD, Fun) ->
+    TS = traverse(TS0, Fun),
+    TD#typedef{typespec=TS};
+traverse_1(#valuedef{type=TS0} = VD, Fun) ->
+    TS = traverse(TS0, Fun),
+    VD#valuedef{type=TS};
+traverse_1(#type{def=TS0} = TD, Fun) ->
+    TS = traverse(TS0, Fun),
+    TD#type{def=TS};
+traverse_1(#'SEQUENCE'{components=Cs0} = Seq, Fun) ->
+    Cs = traverse_seq_set(Cs0, Fun),
+    Seq#'SEQUENCE'{components=Cs};
+traverse_1({'SEQUENCE OF',Type0}, Fun) ->
+    Type = traverse(Type0, Fun),
+    {'SEQUENCE OF',Type};
+traverse_1({'SET OF',Type0}, Fun) ->
+    Type = traverse(Type0, Fun),
+    {'SET OF',Type};
+traverse_1(#'SET'{components=Cs0} = Set, Fun) ->
+    Cs = traverse_seq_set(Cs0, Fun),
+    Set#'SET'{components=Cs};
+traverse_1({'CHOICE', Cs0}, Fun) ->
+    Cs = traverse_seq_set(Cs0, Fun),
+    {'CHOICE', Cs};
+traverse_1(Leaf, _) ->
+    Leaf.
+
+traverse_seq_set(List, Fun) when is_list(List) ->
+    traverse_seq_set_1(List, Fun);
+traverse_seq_set({Set, Ext}, Fun) ->
+    {traverse_seq_set_1(Set, Fun), traverse_seq_set_1(Ext, Fun)};
+traverse_seq_set({Set1, Set2, Set3}, Fun) ->
+    {traverse_seq_set_1(Set1, Fun),
+     traverse_seq_set_1(Set2, Fun),
+     traverse_seq_set_1(Set3, Fun)}.
+
+traverse_seq_set_1([#'ComponentType'{} = CT0|Cs], Fun) ->
+    CT = #'ComponentType'{typespec=TS0} = Fun(CT0),
+    TS = traverse(TS0, Fun),
+    [CT#'ComponentType'{typespec=TS}|traverse_seq_set_1(Cs, Fun)];
+traverse_seq_set_1([{'COMPONENTS OF', _} = CO0|Cs], Fun) ->
+    {'COMPONENTS OF', TS0} = Fun(CO0),
+    TS = traverse(TS0, Fun),
+    [{'COMPONENTS OF', TS}|traverse_seq_set_1(Cs, Fun)];
+traverse_seq_set_1([], _) ->
+    [].
 
-object_to_check(#typedef{typespec=ObjDef}) ->
+object_to_check(_, #typedef{typespec=ObjDef}) ->
     ObjDef;
-object_to_check(#valuedef{type=ClassName,value=ObjectRef}) ->
+object_to_check(S, #valuedef{type=Class,value=ObjectRef}) ->
     %% If the object definition is parsed as an object the ClassName
-    %% is parsed as a type
-    #'Object'{classname=ClassName#type.def,def=ObjectRef}.
-
-prepare_objset({'SingleValue',Set}) when is_list(Set) ->
-    {set,Set,false};
-prepare_objset(L=['EXTENSIONMARK']) ->
-    L;
-prepare_objset(Set) when is_list(Set) ->
-    {set,Set,false};
-prepare_objset({{'SingleValue',Set},Ext}) ->
-    {set,merge_sets(Set,Ext),true};
-%%prepare_objset({Set,Ext}) when is_list(Set),is_list(Ext) ->
-%%    {set,lists:append([Set,Ext]),true};
-prepare_objset({Set,Ext}) when is_list(Set) ->
-    {set,merge_sets(Set,Ext),true};
-prepare_objset({{object,definedsyntax,_ObjFields}=Set,Ext}) ->
-    {set,merge_sets(Set, Ext),true};
-prepare_objset(ObjDef={object,definedsyntax,_ObjFields}) ->
-    {set,[ObjDef],false};
-prepare_objset({ObjDef=#type{},Ext}) when is_list(Ext) ->
-    {set,[ObjDef|Ext],true};
-prepare_objset(Ret) ->
-    Ret.
-
-class_fields_optional_check(S,#classdef{typespec=ClassSpec}) ->
-    Fields = ClassSpec#objectclass.fields,
-    class_fields_optional_check1(S,Fields).
-
-class_fields_optional_check1(_S,[]) ->
-    ok;
-class_fields_optional_check1(S,[{typefield,_,'OPTIONAL'}|Rest]) ->
-    class_fields_optional_check1(S,Rest);
-class_fields_optional_check1(S,[{fixedtypevaluefield,_,_,_,'OPTIONAL'}|Rest]) ->
-    class_fields_optional_check1(S,Rest);
-class_fields_optional_check1(S,[{fixedtypevaluesetfield,_,_,'OPTIONAL'}|Rest]) ->
-    class_fields_optional_check1(S,Rest);
-class_fields_optional_check1(S,[{objectfield,_,_,_,'OPTIONAL'}|Rest]) ->
-    class_fields_optional_check1(S,Rest);
-class_fields_optional_check1(S,[{objectsetfield,_,_,'OPTIONAL'}|Rest]) ->
-    class_fields_optional_check1(S,Rest).
-
-%% ObjectSetFromObjects functionality
-
-%% The fieldname is a list of field names.They may be objects or
-%% object sets. If ObjectSet is an object set the resulting object set
-%% is the union of object sets if the last field name is an object
-%% set.  If the last field is an object the resulting object set is
-%% the set of objects in ObjectSet.
-object_set_from_objects(S,RefedObjMod,FieldName,ObjectSet) ->
-    object_set_from_objects(S,RefedObjMod,FieldName,ObjectSet,[]).
-object_set_from_objects(S,RefedObjMod,FieldName,ObjectSet,InterSect)
-  when is_record(ObjectSet,'ObjectSet') ->
-    #'ObjectSet'{class=Cl,set=Set} = ObjectSet,
-    {_,ClassDef} = get_referenced_type(S,Cl),
-    object_set_from_objects(S,RefedObjMod,ClassDef,FieldName,Set,InterSect,[]);
-object_set_from_objects(S,RefedObjMod,FieldName,Object,InterSect) 
-  when is_record(Object,'Object') ->
-    #'Object'{classname=Cl,def=Def}=Object,
-    object_set_from_objects(S,RefedObjMod,Cl,FieldName,[Def],InterSect,[]).
-object_set_from_objects(S,RefedObjMod,ClassDef,FieldName,['EXTENSIONMARK'|Os],
-			InterSect,Acc) ->
-    object_set_from_objects(S,RefedObjMod,ClassDef,FieldName,Os,InterSect,%%Acc);
-			    ['EXTENSIONMARK'|Acc]);
-object_set_from_objects(S,RefedObjMod,ClassDef,FieldName,[O|Os],InterSect,Acc) ->
-    case object_set_from_objects2(S,mod_of_obj(RefedObjMod,element(1,O)),
-				  ClassDef,FieldName,element(3,O),InterSect) of
-	ObjS when is_list(ObjS) ->
-	    object_set_from_objects(S,RefedObjMod,ClassDef,FieldName,Os,InterSect,ObjS++Acc);
-	Obj ->
-	    object_set_from_objects(S,RefedObjMod,ClassDef,FieldName,Os,InterSect,[Obj|Acc])
-    end;
-object_set_from_objects(_S,_RefedObjMod,_ClassDef,_FieldName,[],InterSect,Acc) ->
-    %% For instance may Acc contain objects of same class from
-    %% different object sets that in fact might be duplicates.
-    remove_duplicate_objects(osfo_intersection(InterSect,Acc)).
-%%    Acc.
-object_set_from_objects2(S,RefedObjMod,ClassDef,[{valuefieldreference,OName}],
-			 Fields,_InterSect) ->
-    %% this is an object
-    case lists:keysearch(OName,1,Fields) of
-	{value,{_,TDef}} ->
-	    mk_object_set_from_object(S,RefedObjMod,TDef,ClassDef);
+    %% is parsed as a type.
+    case Class of
+	#type{def=#'Externaltypereference'{}=Def} ->
+	    #'Object'{classname=Def,def=ObjectRef};
 	_ ->
-	    [] % it may be an absent optional field
-    end;
-object_set_from_objects2(S,RefedObjMod,ClassDef,[{typefieldreference,OSName}],
-			Fields,_InterSect) ->
-    %% this is an object set
-    case lists:keysearch(OSName,1,Fields) of
-	{value,{_,TDef}} ->
-	    case TDef#typedef.typespec of
-		#'ObjectSet'{class=_NextClName,set=NextSet} ->%% = TDef#typedef.typespec,
-		    NextSet;
-		#'Object'{def=_ObjDef} ->
-		    mk_object_set_from_object(S,RefedObjMod,TDef,ClassDef)
-%%		    ObjDef
-		    %% error({error,{internal,unexpected_object,TDef}})
-	    end;
-	_ ->
-	    [] % it may be an absent optional field
-    end;
-object_set_from_objects2(S,RefedObjMod,_ClassDef,[{valuefieldreference,OName}|Rest],
-			 Fields,InterSect) ->
-    %% this is an object
-    case lists:keysearch(OName,1,Fields) of
-	{value,{_,TDef}} ->
-	    #'Object'{classname=NextClName,def=ODef}=TDef#typedef.typespec,
-	    {_,_,NextFields}=ODef,
-	    {_,NextClass} = get_referenced_type(S,NextClName),
-	    object_set_from_objects2(S,RefedObjMod,NextClass,Rest,NextFields,InterSect);
-	_ ->
-	    []
-    end;
-object_set_from_objects2(S,RefedObjMod,_ClassDef,[{typefieldreference,OSName}|Rest],
-			Fields,InterSect) ->
-    %% this is an object set
-    Next = {NextClName,NextSet} = 
-	case lists:keysearch(OSName,1,Fields) of
-	    {value,{_,TDef}} when is_record(TDef,'ObjectSet') ->    
-		#'ObjectSet'{class=NextClN,set=NextS} = TDef,
-		{NextClN,NextS};
-	    {value,{_,#typedef{typespec=OS}}} ->
-		%% objectsets in defined syntax will come here as typedef{}
-		%% #'ObjectSet'{class=NextClN,set=NextS} = OS,
-		case OS of
-		    #'ObjectSet'{class=NextClN,set=NextS} ->
-			{NextClN,NextS};
-		    #'Object'{classname=NextClN,def=NextDef} ->
-			{NextClN,[NextDef]}
-		end;
-	_ ->
-	    {[],[]}
-    end,
-    case Next of
-	{[],[]} ->
-	    [];
-	_ ->
-	    {_,NextClass} = get_referenced_type(S,NextClName),
-	    object_set_from_objects(S,RefedObjMod,NextClass,Rest,NextSet,InterSect,[])
-    end.
-		
-mk_object_set_from_object(S,RefedObjMod,TDef,Class) -> 
-    #'Object'{classname=_NextClName,def=ODef} = TDef#typedef.typespec,
-    {_,_,NextFields}=ODef,
-
-    UniqueFieldName = 
-	case (catch get_unique_fieldname(S,Class)) of
-	    {error,'__undefined_',_} -> {unique,undefined};
-	    {asn1,Msg,_} -> error({class,Msg,S});
-	    {'EXIT',Msg} -> error({class,{internal_error,Msg},S});
-	    {Other,_} -> Other
-	end,
-    VDef = get_unique_value(S,NextFields,UniqueFieldName),
-    %% XXXXXXXXXXX
-    case VDef of
-	[] ->
-	    ['EXTENSIONMARK'];
-	_ ->
-	    {{RefedObjMod,get_datastr_name(TDef)},VDef,NextFields}    
-    end.
-    
-    
-mod_of_obj(_RefedObjMod,{NewMod,ObjName}) 
-  when is_atom(NewMod),is_atom(ObjName) ->
-    NewMod;
-mod_of_obj(RefedObjMod,_) ->
-    RefedObjMod.
-    
-
-merge_sets(Root,{'SingleValue',Ext}) ->
-    merge_sets(Root,Ext);
-merge_sets(Root,Ext) when is_list(Root),is_list(Ext) ->
-    Root ++ Ext;
-merge_sets(Root,Ext) when is_list(Ext) ->
-    [Root|Ext];
-merge_sets(Root,Ext) when is_list(Root) ->
-    Root++[Ext];
-merge_sets(Root,Ext) ->
-    [Root]++[Ext].
-
-reduce_objectset(ObjectSet,Exclusion) ->
-    case Exclusion of
-	{'SingleValue',#'Externalvaluereference'{value=Name}} ->
-	    case lists:keysearch(Name,1,ObjectSet) of
-		{value,El} ->
-		    lists:subtract(ObjectSet,[El]);
-		_ ->
-		    ObjectSet
-	    end
+	    asn1_error(S, illegal_object)
     end.
-	    
-%% Checks a list of objects or object sets and returns a list of selected
-%% information for the code generation.
-check_object_list(S,ClassRef,ObjectList) ->
-    check_object_list(S,ClassRef,ObjectList,[]).
-
-check_object_list(S,ClassRef,[ObjOrSet|Objs],Acc) ->
-    ?dbg("check_object_list: ~p~n",[ObjOrSet]),
-    case ObjOrSet of
-	ObjDef when is_tuple(ObjDef),(element(1,ObjDef)==object) ->
-	    Def = 
-		check_object(S,#typedef{typespec=ObjDef},
-%			     #'Object'{classname={objectclassname,ClassRef},
-			     #'Object'{classname=ClassRef,
-				       def=ObjDef}),
-	    check_object_list(S,ClassRef,Objs,[{{no_mod,no_name},Def#'Object'.def}|Acc]);
-	{'SingleValue',Ref = #'Externalvaluereference'{}} ->
-	    ?dbg("{SingleValue,Externalvaluereference}~n",[]),
-	    {RefedMod,ObjName,
-	     #'Object'{def=Def}} = check_referenced_object(S,Ref),
-	    check_object_list(S,ClassRef,Objs,[{{RefedMod,ObjName},Def}|Acc]);
-	ObjRef when is_record(ObjRef,'Externalvaluereference') ->
-	    ?dbg("Externalvaluereference~n",[]),
-	    {RefedMod,ObjName,
-	     #'Object'{def=Def}} = check_referenced_object(S,ObjRef),
-	     check_object_list(S,ClassRef,Objs,[{{RefedMod,ObjName},Def}|Acc]);
-	{'ValueFromObject',{_,Object},FieldName} ->
-	    {_,Def} = get_referenced_type(S,Object),
-	    TypeDef = get_fieldname_element(S,Def,FieldName),
-	    (TypeDef#typedef.typespec)#'ObjectSet'.set;
-	ObjSet when is_record(ObjSet,type) ->
-	    ObjSetDef = 
-		case ObjSet#type.def of
-		    Ref when is_record(Ref,'Externaltypereference') ->
-			{_,D} = get_referenced_type(S,ObjSet#type.def),
-			D;
-		    Other ->
-			throw({asn1_error,{'unknown objecset',Other,S}})
-		end,
-	    #'ObjectSet'{set=ObjectsInSet} = 
-		check_object(S,ObjSetDef,ObjSetDef#typedef.typespec),
-	    AccList = transform_set_to_object_list(ObjectsInSet,[]),
-	    check_object_list(S,ClassRef,Objs,AccList++Acc);
-	union ->
-	    check_object_list(S,ClassRef,Objs,Acc);
-	{pos,{objectset,_,DefinedObjectSet},Params} ->
-	    OSDef = #type{def={pt,DefinedObjectSet,Params}},
-	    #'ObjectSet'{set=Set} =
-		check_object(S,ObjOrSet,#'ObjectSet'{class=ClassRef,
-						     set=OSDef}),
-	    check_object_list(S,ClassRef,Objs,Set ++ Acc);
-	{pv,{simpledefinedvalue,DefinedObject},Params} ->
-	    Args = [match_parameters(S,Param,S#state.parameters)||
-		       Param<-Params],
-	    #'Object'{def=Def} =
-		check_object(S,ObjOrSet,
-			     #'Object'{classname=ClassRef ,
-				       def={po,{object,DefinedObject},
-					    Args}}),
-	    check_object_list(S,ClassRef,Objs,[{{no_mod,no_name},Def}|Acc]);
-	{'ObjectSetFromObjects',Os,FieldName} when is_tuple(Os) ->
-	    NewSet =
-		check_ObjectSetFromObjects(S, element(tuple_size(Os), Os),
-					   FieldName,[]),
-	    check_object_list(S,ClassRef,Objs,NewSet++Acc);
-	{{'ObjectSetFromObjects',Os,FieldName},InterSection}
-	when is_tuple(Os) ->
-	    NewSet =
-		check_ObjectSetFromObjects(S, element(tuple_size(Os), Os),
-					   FieldName,InterSection),
-	    check_object_list(S,ClassRef,Objs,NewSet++Acc);
-	Other ->
-	    exit({error,{'unknown object',Other},S})
-    end;
-%% Finally reverse the accumulated list and if there are any extension
-%% marks in the object set put one indicator of that in the end of the
-%% list.
-check_object_list(_,_,[],Acc) ->
-    lists:reverse(Acc).
 
 check_referenced_object(S,ObjRef) 
   when is_record(ObjRef,'Externalvaluereference')->
@@ -1230,180 +1003,134 @@ check_referenced_object(S,ObjRef)
 	     check_object(update_state(S,RefedMod),ObjectDef,ObjectDef#typedef.typespec)}
     end.
 
-check_ObjectSetFromObjects(S,ObjName,FieldName,InterSection) ->
-    {RefedMod,TDef} = get_referenced_type(S,ObjName),
-    ObjOrSet = check_object(update_state(S,RefedMod),TDef,TDef#typedef.typespec),
-    InterSec = prepare_intersection(S,InterSection),
-    _NewSet = object_set_from_objects(S,RefedMod,FieldName,ObjOrSet,InterSec).
+check_ObjectSetFromObjects(S, ObjName, Fields) ->
+    {_,Obj0} = get_referenced_type(S, ObjName),
+    case check_object(S, Obj0, Obj0#typedef.typespec) of
+	#'ObjectSet'{}=Obj1 ->
+	    get_fieldname_set(S, Obj1, Fields);
+	#'Object'{classname=Class,
+		  def={object,_,ObjFs}} ->
+	    ObjSet = #'ObjectSet'{class=Class,
+				  set=[{'_','_',ObjFs}]},
+	    get_fieldname_set(S, ObjSet, Fields)
+    end.
 
-prepare_intersection(_S,[]) ->
-    [];
-prepare_intersection(S,{'EXCEPT',ObjRef}) ->
-    except_names(S,ObjRef);
-prepare_intersection(_S,T) ->
-    exit({error,{internal_error,not_implemented,object_set_from_objects,T}}).
-except_names(_S,{'SingleValue',#'Externalvaluereference'{value=ObjName}})  ->
-    [{except,ObjName}];
-except_names(_,T) ->
-    exit({error,{internal_error,not_implemented,object_set_from_objects,T}}).
-
-osfo_intersection(InterSect,ObjList) ->
-    Res = [X|| X = {{_,N},_,_} <- ObjList,
-	       lists:member({except,N},InterSect) == false],
-    case lists:member('EXTENSIONMARK',ObjList) of
-	true ->
-	    Res ++ ['EXTENSIONMARK'];
+%%  get_type_from_object(State, ObjectOrObjectSet, [{RefType,FieldName}]) ->
+%%    Type
+get_type_from_object(S, Object, FieldNames)
+  when is_record(Object, 'Externaltypereference');
+       is_record(Object, 'Externalvaluereference') ->
+    extract_field(S, Object, FieldNames).
+
+%% get_value_from_object(State, ObjectOrObjectSet, [{RefType,FieldName}]) ->
+%%    UntaggedValue
+get_value_from_object(S, Def, FieldNames) ->
+    case extract_field(S, Def, FieldNames) of
+	#valuedef{value=Val} ->
+	    Val;
+	{valueset,_}=Val ->
+	    Val;
 	_ ->
-	    Res
+	    asn1_error(S, illegal_value)
     end.
 
-%%  get_fieldname_element/3
-%%  gets the type/value/object/... of the referenced element in FieldName
-%%  FieldName is a list and may have more than one element.
-%%  Each element in FieldName can be either {typefieldreference,AnyFieldName}
-%%  or {valuefieldreference,AnyFieldName}
-%%  Def is the def of the first object referenced by FieldName
-get_fieldname_element(S,Def,[{_RefType,FieldName}]) when is_record(Def,typedef) ->
-    {_,_,ObjComps} = (Def#typedef.typespec)#'Object'.def,
-    check_fieldname_element(S,lists:keysearch(FieldName,1,ObjComps));
-get_fieldname_element(S,Def,[{_RefType,FieldName}|Rest])
-  when is_record(Def,typedef) ->
-    %% As FieldName is followd by other FieldNames it has to be an
-    %% object or objectset.
-    {_,_,ObjComps} = (Def#typedef.typespec)#'Object'.def,
-    NewDef = check_fieldname_element(S,lists:keysearch(FieldName,1,ObjComps)),
-    ObjDef = fun(#'Object'{def=D}) -> D;
-		(#'ObjectSet'{set=Set}) -> Set
-	     end 
-	       (NewDef),
-    case ObjDef of
-	L when is_list(L) ->
-	    [get_fieldname_element(S,X,Rest) || X <- L];
-	_ ->
-	    get_fieldname_element(S,ObjDef,Rest)
+%% extract_field(State, ObjectOrObjectSet, [{RefType,FieldName}])
+%%   RefType = typefieldreference | valuefieldreference
+%%
+%%   Get the type, value, object, object set, or value set from the
+%%   referenced object or object set. The list of field name tuples
+%%   may have more than one element.  All field names but the last
+%%   refers to either an object or object set.
+
+extract_field(S, Def0, FieldNames) ->
+    {_,Def1} = get_referenced_type(S, Def0),
+    Def2 = check_object(S, Def1, Def1#typedef.typespec),
+    Def = Def1#typedef{typespec=Def2},
+    get_fieldname_element(S, Def, FieldNames).
+
+%% get_fieldname_element(State, Element, [{RefType,FieldName}]
+%%   RefType = typefieldreference | valuefieldreference
+%%
+%%   Get the type, value, object, object set, or value set from the referenced
+%%   element. The list of field name tuples may have more than one element.
+%%   All field names but the last refers to either an object or object set.
+
+get_fieldname_element(S, Object0, [{_RefType,FieldName}|Fields]) ->
+    Object = case Object0 of
+		 #typedef{typespec=#'Object'{def=Obj}} -> Obj;
+		 {_,_,_}=Obj -> Obj
+	     end,
+    case check_fieldname_element(S, FieldName, Object) of
+	#'Object'{def=D} when Fields =/= [] ->
+	    get_fieldname_element(S, D, Fields);
+	#'ObjectSet'{}=Set ->
+	    get_fieldname_set(S, Set, Fields);
+	Result when Fields =:= [] ->
+	    Result
     end;
-get_fieldname_element(S,{object,_,Fields},[{_RefType,FieldName}|Rest]) ->
-    NewDef = check_fieldname_element(S,lists:keysearch(FieldName,1,Fields)),
-    get_fieldname_element(S,NewDef,Rest);
-get_fieldname_element(_S,Def,[]) -> 
-    Def;
-get_fieldname_element(_S,Def,[{_RefType,_FieldName}|_RestFName]) 
-  when is_record(Def,typedef) ->
-    ok.
+get_fieldname_element(_S, Def, []) ->
+    Def.
 
-check_fieldname_element(S,{value,{_,Def}}) ->
-    check_fieldname_element(S,Def);
-check_fieldname_element(S,TDef)  when is_record(TDef,typedef) ->
-    check_type(S,TDef,TDef#typedef.typespec);
-check_fieldname_element(S,VDef) when is_record(VDef,valuedef) ->
-    check_value(S,VDef);
-check_fieldname_element(S,Eref)
-  when is_record(Eref,'Externaltypereference');
-       is_record(Eref,'Externalvaluereference') ->
-    {_,TDef}=get_referenced_type(S,Eref),
-    check_fieldname_element(S,TDef);
-check_fieldname_element(S,Other) ->
-    throw({error,{assigned_object_error,"not_assigned_object",Other,S}}).
-    
-transform_set_to_object_list([{Name,_UVal,Fields}|Objs],Acc) ->
-    transform_set_to_object_list(Objs,[{Name,{object,generatesyntax,Fields}}|Acc]);
-transform_set_to_object_list(['EXTENSIONMARK'|Objs],Acc) ->
-%%    transform_set_to_object_list(Objs,['EXTENSIONMARK'|Acc]);
-    transform_set_to_object_list(Objs,Acc);
-transform_set_to_object_list([],Acc) ->
-    Acc.
+get_fieldname_set(S, #'ObjectSet'{set=Set0}, T) ->
+    get_fieldname_set_1(S, Set0, T, []).
 
-get_unique_valuelist(_S,ObjSet,{unique,undefined}) -> % no unique field in object
-    lists:map(fun({N,{_,_,F}})->{N,no_unique_value,F};
-		 (V={_,_,_}) ->V;
-		 ({A,B}) -> {A,no_unique_value,B} 
-	      end, ObjSet);
-get_unique_valuelist(S,ObjSet,{UFN,Opt}) ->
-    get_unique_vlist(S,ObjSet,UFN,Opt,[]).
-
-
-get_unique_vlist(_S,[],_,_,[]) ->
-    ['EXTENSIONMARK'];
-get_unique_vlist(S,[],_,Opt,Acc) ->
-    case catch check_uniqueness(remove_duplicate_objects(Acc)) of
-	{asn1_error,_} when Opt =/= 'OPTIONAL' ->
-	    error({'ObjectSet',"not unique objects in object set",S});
-	{asn1_error,_} ->
-	    lists:reverse(Acc);
-	_ ->
-	    lists:reverse(Acc)
+get_fieldname_set_1(S, ['EXTENSIONMARK'=Ext|T], Fields, Acc) ->
+    get_fieldname_set_1(S, T, Fields, [Ext|Acc]);
+get_fieldname_set_1(S, [H|T], Fields, Acc) ->
+    try get_fieldname_element(S, H, Fields) of
+	L when is_list(L) ->
+	    get_fieldname_set_1(S, T, Fields, L++Acc);
+	{valueset,L} ->
+	    get_fieldname_set_1(S, T, Fields, L++Acc);
+	Other ->
+	    get_fieldname_set_1(S, T, Fields, [Other|Acc])
+    catch
+	throw:{error,_} ->
+	    get_fieldname_set_1(S, T, Fields, Acc)
     end;
-get_unique_vlist(S,['EXTENSIONMARK'|Rest],UniqueFieldName,Opt,Acc) ->
-    get_unique_vlist(S,Rest,UniqueFieldName,Opt,Acc);
-get_unique_vlist(S,[{ObjName,Obj}|Rest],UniqueFieldName,Opt,Acc) ->
-    {_,_,Fields} = Obj,
-    NewObjInf = 
-	case get_unique_value(S,Fields,UniqueFieldName) of
-	    #valuedef{value=V} -> [{ObjName,V,Fields}];
-	    [] -> []; % maybe the object only was a reference to an
-                     % empty object set.
-	    no_unique_value -> [{ObjName,no_unique_value,Fields}]
-	end,
-    get_unique_vlist(S,Rest,UniqueFieldName,Opt,NewObjInf++Acc);
-
-get_unique_vlist(S,[V={_,_,_}|Rest],UniqueFieldName,Opt,Acc) ->
-    get_unique_vlist(S,Rest,UniqueFieldName,Opt,[V|Acc]).
-
-get_unique_value(S,Fields,UniqueFieldName) ->
-    Module = S#state.mname,
-    case lists:keysearch(UniqueFieldName,1,Fields) of
-	{value,Field} ->
-	    case element(2,Field) of
-		VDef when is_record(VDef,valuedef) ->
-		    VDef;
-		{'ValueFromObject',Object,Name} ->
-		    case Object of
-			{object,Ext} when is_record(Ext,'Externaltypereference') ->
-			    OtherModule = Ext#'Externaltypereference'.module,
-			    ExtObjName = Ext#'Externaltypereference'.type,
-			    ObjDef = asn1_db:dbget(OtherModule,ExtObjName),
-			    ObjSpec = ObjDef#typedef.typespec,
-			    get_unique_value(OtherModule,element(3,ObjSpec),Name);
-			{object,{_,_,ObjName}} ->
-			    ObjDef = asn1_db:dbget(Module,ObjName),
-			    ObjSpec = ObjDef#typedef.typespec,
-			    get_unique_value(Module,element(3,ObjSpec),Name);
-			{po,Object,_Params} ->
-			    exit({error,{'parameterized object not implemented yet',
-					 Object},S})
-		    end;
-		Value when is_atom(Value);is_number(Value) ->
-		    #valuedef{value=Value,module=Module};
-		{'CHOICE',{C,Value}} when is_atom(C) ->
-		    %% #valuedef{value=normalize_value(S,element(3,Field),VDef,[])}
-		    case Value of
-			Scalar when is_atom(Scalar);is_number(Scalar) ->
-			    #valuedef{value=Value,module=Module};
-			Eref = #'Externalvaluereference'{} ->
-			    element(2,get_referenced_type(S,Eref))
-		    end
-	    end;
-	false ->
-	    case Fields of
-		[{_,#typedef{typespec=#'ObjectSet'{set=['EXTENSIONMARK']}}}] -> 
-		    [];
-		_ ->
-		    no_unique_value
-	    end
+get_fieldname_set_1(_, [], _Fields, Acc) ->
+    case Acc of
+	[#valuedef{}|_] ->
+	    {valueset,Acc};
+	_ ->
+	    Acc
     end.
 
-check_uniqueness(NameValueList) ->
-    check_uniqueness1(lists:keysort(2,NameValueList)).
-
-check_uniqueness1([]) ->
-    true;
-check_uniqueness1([_]) ->
-    true;
-check_uniqueness1([{_,N,_},{_,N,_}|_Rest]) ->
-    throw({asn1_error,{'objects in set must have unique values in UNIQUE fields',N}});
-check_uniqueness1([_|Rest]) ->
-    check_uniqueness1(Rest).
+check_fieldname_element(S, Name, {_,_,Fields}) ->
+    case lists:keyfind(Name, 1, Fields) of
+	{Name,Def} ->
+	    check_fieldname_element_1(S, Def);
+	false ->
+	    asn1_error(S, {undefined_field,Name})
+    end.
 
+check_fieldname_element_1(S, #typedef{typespec=Ts}=TDef) ->
+    case Ts of
+	#'Object'{} ->
+	    check_object(S, TDef, Ts);
+	_ ->
+	    check_type(S, TDef, Ts)
+    end;
+check_fieldname_element_1(S, #valuedef{}=VDef) ->
+    try
+	check_value(S, VDef)
+    catch
+	throw:{asn1_class, _} ->
+	    #valuedef{checked=C,pos=Pos,name=N,type=Type,
+		      value=Def} = VDef,
+	    ClassName = Type#type.def,
+	    NewSpec = #'Object'{classname=ClassName,def=Def},
+	    NewDef = #typedef{checked=C,pos=Pos,name=N,typespec=NewSpec},
+	    check_fieldname_element_1(S, NewDef)
+    end;
+check_fieldname_element_1(_S, {value_tag,Val}) ->
+    #valuedef{value=Val};
+check_fieldname_element_1(S, Eref)
+  when is_record(Eref, 'Externaltypereference');
+       is_record(Eref, 'Externalvaluereference') ->
+    {_,TDef} = get_referenced_type(S, Eref),
+    check_fieldname_element_1(S, TDef).
+    
 %% instantiate_po/4
 %% ClassDef is the class of Object,
 %% Object is the Parameterized object, which is referenced,
@@ -1412,8 +1139,7 @@ check_uniqueness1([_|Rest]) ->
 instantiate_po(S=#state{parameters=_OldArgs},_ClassDef,Object,ArgsList) when is_record(Object,pobjectdef) ->
     FormalParams = get_pt_args(Object),
     MatchedArgs = match_args(S,FormalParams,ArgsList,[]),
-%    NewS = S#state{type=Object,parameters=MatchedArgs++OldArgs},
-    NewS = S#state{type=Object,parameters=MatchedArgs},
+    NewS = S#state{parameters=MatchedArgs},
     check_object(NewS,Object,#'Object'{classname=Object#pobjectdef.class,
 				    def=Object#pobjectdef.def}).
 
@@ -1423,20 +1149,14 @@ instantiate_po(S=#state{parameters=_OldArgs},_ClassDef,Object,ArgsList) when is_
 %% on the right side of the assignment,
 %% ArgsList is the list of actual parameters, i.e. real objects
 instantiate_pos(S=#state{parameters=_OldArgs},ClassRef,ObjectSetDef,ArgsList) ->
-%    ClassName = ClassDef#classdef.name,
     FormalParams = get_pt_args(ObjectSetDef),
     OSet = case get_pt_spec(ObjectSetDef) of
-	      {valueset,Set} -> 
-% 		   #'ObjectSet'{class=name2Extref(S#state.mname,
-% 						  ClassName),set=Set};
-		   #'ObjectSet'{class=ClassRef,set=Set};
-	      Set when is_record(Set,'ObjectSet') -> Set;
-	       _ ->
-		   error({type,"parameterized object set failure",S})
+	       {valueset,Set} -> #'ObjectSet'{class=ClassRef,set=Set};
+	       Set when is_record(Set,'ObjectSet') -> Set;
+	       _ -> asn1_error(S, invalid_objectset)
 	   end,
     MatchedArgs = match_args(S,FormalParams,ArgsList,[]),
-%    NewS = S#state{type=ObjectSetDef,parameters=MatchedArgs++OldArgs},
-    NewS = S#state{type=ObjectSetDef,parameters=MatchedArgs},
+    NewS = S#state{parameters=MatchedArgs},
     check_object(NewS,ObjectSetDef,OSet).
 
     
@@ -1470,7 +1190,7 @@ gen_incl1(S,Fields,[C|CFields]) ->
 				check_object(S,TDef,TDef#typedef.typespec);
 			    ERef ->
 				{_,T} = get_referenced_type(S,ERef),
-				check_object(S,T,object_to_check(T))
+				check_object(S, T, object_to_check(S, T))
 			end,
 		    case gen_incl(S,ObjDef#'Object'.def,
 				  ClassFields) of
@@ -1487,7 +1207,7 @@ gen_incl1(S,Fields,[C|CFields]) ->
     end.
 
 get_objclass_fields(S,Eref=#'Externaltypereference'{}) ->
-    {_,ClassDef} = get_referenced_type(S,Eref),
+    {_,ClassDef} = get_referenced_type(S,Eref, true),
     get_objclass_fields(S,ClassDef);
 get_objclass_fields(S,CD=#classdef{typespec=#'Externaltypereference'{}}) ->
     get_objclass_fields(S,CD#classdef.typespec);
@@ -1503,10 +1223,10 @@ gen_incl_set(S,Fields,#typedef{typespec=#type{def=Eref}})
     {_,CDef} = get_referenced_type(S,Eref),
     gen_incl_set(S,Fields,CDef);
 gen_incl_set(S,Fields,ClassDef) ->
-    case catch get_unique_fieldname(S,ClassDef) of
-	Tuple when tuple_size(Tuple) =:= 3 ->
+    case get_unique_fieldname(S, ClassDef) of
+	no_unique ->
 	    false;
-	_ ->
+	{_, _} ->
 	    gen_incl_set1(S,Fields,
 			  (ClassDef#classdef.typespec)#objectclass.fields)
     end.
@@ -1531,450 +1251,393 @@ gen_incl_set1(S,[Object|Rest],CFields)->
 	    gen_incl_set1(S,Rest,CFields)
     end.
 
-check_objectdefn(S,Def,CDef) when is_record(CDef,classdef) ->
-    WithSyntax = (CDef#classdef.typespec)#objectclass.syntax,
-    ClassFields = (CDef#classdef.typespec)#objectclass.fields,
+
+%%%
+%%% Check an object definition.
+%%%
+
+check_objectdefn(S, Def, #classdef{typespec=ObjClass}) ->
+    #objectclass{syntax=Syntax0,fields=ClassFields} = ObjClass,
     case Def of
 	{object,defaultsyntax,Fields} ->
-	    check_defaultfields(S,Fields,ClassFields);
+	    check_defaultfields(S, Fields, ClassFields);
 	{object,definedsyntax,Fields} ->
-	    {_,WSSpec} = WithSyntax,
-	    NewFields = 
-		case catch( convert_definedsyntax(S,Fields,WSSpec,
-						  ClassFields,[])) of
-		    {asn1,{_ErrorType,ObjToken,ClassToken}} ->
-			throw({asn1,{'match error in object',ObjToken,
-				     'found in object',ClassToken,'found in class'}});
-		    Err={asn1,_} -> throw(Err);
-		    Err={'EXIT',_} -> throw(Err);
-		    DefaultFields when is_list(DefaultFields) ->
-			DefaultFields
-		end,
-	    {object,defaultsyntax,NewFields};
-	{object,_ObjectId} -> % This is a DefinedObject
-	    fixa;
-	Other ->
-	    exit({error,{objectdefn,Other}})
+	    Syntax = get_syntax(S, Syntax0, ClassFields),
+	    case match_syntax(S, Syntax, Fields, []) of
+		{match,NewFields,[]} ->
+		    {object,defaultsyntax,NewFields};
+		{match,_,[What|_]} ->
+		    syntax_match_error(S, What);
+		{nomatch,[What|_]} ->
+		    syntax_match_error(S, What);
+		{nomatch,[]} ->
+		    syntax_match_error(S)
+	    end
     end.
 
-check_defaultfields(S,Fields,ClassFields) ->
-    check_defaultfields(S,Fields,ClassFields,[]).
 
-check_defaultfields(_S,[],_ClassFields,Acc) ->
-    {object,defaultsyntax,lists:reverse(Acc)};
-check_defaultfields(S,[{FName,Spec}|Fields],ClassFields,Acc) ->
-    case lists:keysearch(FName,2,ClassFields) of
-	{value,CField} ->
-	    {NewField,RestFields} = 
-		convert_to_defaultfield(S,FName,[Spec|Fields],CField),
-	    check_defaultfields(S,RestFields,ClassFields,[NewField|Acc]);
-	_ ->
-	    throw({error,{asn1,{'unvalid field in object',FName}}})
-    end.
-%%    {object,defaultsyntax,Fields}.
+%%%
+%%% Pre-process the simplified syntax so that it can be more
+%%% easily matched.
+%%%
 
-convert_definedsyntax(_S,[],[],_ClassFields,Acc) ->
-    lists:reverse(Acc);
-convert_definedsyntax(S,Fields,WithSyntax,ClassFields,Acc) ->
-    {MatchedField,RestFields,RestWS} =
-	match_field(S,Fields,WithSyntax,ClassFields),
-    if
-	is_list(MatchedField) ->
-	    convert_definedsyntax(S,RestFields,RestWS,ClassFields,
-				  lists:append(MatchedField,Acc));
+get_syntax(_, {preprocessed_syntax,Syntax}, _) ->
+    Syntax;
+get_syntax(S, {'WITH SYNTAX',Syntax}, ClassFields) ->
+    preprocess_syntax(S, Syntax, ClassFields).
+
+preprocess_syntax(S, Syntax0, Cs) ->
+    Syntax = preprocess_syntax_1(S, Syntax0, Cs, true),
+    Present0 = preprocess_get_fields(Syntax, []),
+    Present1 = lists:sort(Present0),
+    Present = ordsets:from_list(Present1),
+    case Present =:= Present1 of
+	false ->
+	    Dupl = Present1 -- Present,
+	    asn1_error(S, {syntax_duplicated_fields,Dupl});
 	true ->
-	    convert_definedsyntax(S,RestFields,RestWS,ClassFields,
-				  [MatchedField|Acc])
+	    ok
+    end,
+    Mandatory0 = get_mandatory_class_fields(Cs),
+    Mandatory = ordsets:from_list(Mandatory0),
+    case ordsets:subtract(Mandatory, Present) of
+	[] ->
+	    Syntax;
+	[_|_]=Missing ->
+	    asn1_error(S, {syntax_missing_mandatory_fields,Missing})
     end.
 
-match_field(S,Fields,WithSyntax,ClassFields) ->
-    match_field(S,Fields,WithSyntax,ClassFields,[]).
+preprocess_syntax_1(S, [H|T], Cs, Mandatory) when is_list(H) ->
+    [{optional,preprocess_syntax_1(S, H, Cs, false)}|
+     preprocess_syntax_1(S, T, Cs, Mandatory)];
+preprocess_syntax_1(S, [{valuefieldreference,Name}|T], Cs, Mandatory) ->
+    F = preprocess_check_field(S, Name, Cs, Mandatory),
+    [F|preprocess_syntax_1(S, T, Cs, Mandatory)];
+preprocess_syntax_1(S, [{typefieldreference,Name}|T], Cs, Mandatory) ->
+    F = preprocess_check_field(S, Name, Cs, Mandatory),
+    [F|preprocess_syntax_1(S, T, Cs, Mandatory)];
+preprocess_syntax_1(S,[{Token,_}|T], Cs, Mandatory) when is_atom(Token) ->
+    [{token,Token}|preprocess_syntax_1(S, T, Cs, Mandatory)];
+preprocess_syntax_1(S, [Token|T], Cs, Mandatory) when is_atom(Token) ->
+    [{token,Token}|preprocess_syntax_1(S, T, Cs, Mandatory)];
+preprocess_syntax_1(_, [], _, _) -> [].
+
+preprocess_check_field(S, Name, Cs, Mandatory) ->
+    case lists:keyfind(Name, 2, Cs) of
+	Tuple when is_tuple(Tuple) ->
+	    case not Mandatory andalso is_mandatory_class_field(Tuple) of
+		true ->
+		    asn1_error(S, {syntax_mandatory_in_optional_group,Name});
+		false ->
+		    {field,Tuple}
+	    end;
+	false ->
+	    asn1_error(S, {syntax_undefined_field,Name})
+    end.
 
-match_field(S,Fields,[W|Ws],ClassFields,Acc) when is_list(W) ->
-    case catch(match_optional_field(S,Fields,W,ClassFields,[])) of
-	{'EXIT',_} ->
-	    match_field(Fields,Ws,ClassFields,Acc); %% add S
-%%	{[Result],RestFields} ->
-%%	    {Result,RestFields,Ws};
-	{Result,RestFields} when is_list(Result) ->
-	    {Result,RestFields,Ws};
+preprocess_get_fields([{field,F}|T], Acc) ->
+    Name = element(2, F),
+    preprocess_get_fields(T, [Name|Acc]);
+preprocess_get_fields([{optional,L}|T], Acc) ->
+    preprocess_get_fields(T, preprocess_get_fields(L, Acc));
+preprocess_get_fields([_|T], Acc) ->
+    preprocess_get_fields(T, Acc);
+preprocess_get_fields([], Acc) ->
+    Acc.
+
+%%%
+%%% Match the actual fields in the object definition to
+%%% the pre-processed simplified syntax.
+%%%
+
+match_syntax(S, [{token,Token}|T], [A|As]=Args, Acc) ->
+    case A of
+	{word_or_setting,_,#'Externaltypereference'{type=Token}} ->
+	    match_syntax(S, T, As, Acc);
+	{Token,Line} when is_integer(Line) ->
+	    match_syntax(S, T, As, Acc);
 	_ ->
-	    match_field(S,Fields,Ws,ClassFields,Acc)
+	    {nomatch,Args}
     end;
-match_field(S,Fields,WithSyntax,ClassFields,_Acc) ->
-    match_mandatory_field(S,Fields,WithSyntax,ClassFields,[]).
-
-match_optional_field(_S,RestFields,[],_,Ret) ->
-    {Ret,RestFields};
-%% An additional optional field within an optional field
-match_optional_field(S,Fields,[W|Ws],ClassFields,Ret) when is_list(W) ->
-    case catch match_optional_field(S,Fields,W,ClassFields,[]) of
-	{'EXIT',_} when length(Ws) > 0 ->
-	    match_optional_field(S,Fields,Ws,ClassFields,Ret);
-	{'EXIT',_} ->
-	    {Ret,Fields};
-	{asn1,{optional_matcherror,_,_}} when length(Ws) > 0 ->
-	    match_optional_field(S,Fields,Ws,ClassFields,Ret);
-	{asn1,{optional_matcherror,_,_}} ->
-	    {Ret,Fields};
-	{OptionalField,RestFields} ->
-	    match_optional_field(S,RestFields,Ws,ClassFields,
-				 lists:append(OptionalField,Ret))
+match_syntax(S, [{field,Field}|T]=Fs, [A|As0]=Args0, Acc) ->
+    try match_syntax_type(S, Field, A) of
+	{match,Match} ->
+	    match_syntax(S, T, As0, lists:reverse(Match)++Acc);
+	{params,_Name,#ptypedef{args=Params}=P,Ref} ->
+	    {Args,As} = lists:split(length(Params), As0),
+	    Val = match_syntax_params(S, P, Ref, Args),
+	    match_syntax(S, Fs, [Val|As], Acc)
+    catch
+	_:_ ->
+	    {nomatch,Args0}
     end;
-%% identify and skip word
-match_optional_field(S,[{_,_,#'Externaltypereference'{type=WorS}}|Rest],
-		     [WorS|Ws],ClassFields,Ret) ->
-    match_optional_field(S,Rest,Ws,ClassFields,Ret);
-match_optional_field(S,[],_,ClassFields,Ret) ->
-    match_optional_field(S,[],[],ClassFields,Ret);
-%% identify and skip comma
-match_optional_field(S,[{WorS,_}|Rest],[{WorS,_}|Ws],ClassFields,Ret) ->
-    match_optional_field(S,Rest,Ws,ClassFields,Ret);
-%% am optional setting inside another optional setting may be "double-listed"
-match_optional_field(S,[Setting],DefinedSyntax,ClassFields,Ret) 
-  when is_list(Setting) ->
-    match_optional_field(S,Setting,DefinedSyntax,ClassFields,Ret);
-%% identify and save field data
-match_optional_field(S,[Setting|Rest],[{_,W}|Ws],ClassFields,Ret) ->
-    ?dbg("matching optional field setting: ~p with user friendly syntax: ~p~n",[Setting,W]),
-    WorS =
-	case Setting of
-	    Type when is_record(Type,type) -> Type;
-	    {'ValueFromObject',_,_} -> Setting;
-	    {object,_,_} -> Setting;
-	    {_,_,WordOrSetting} -> WordOrSetting;
-	    Other -> Other
-	end,
-    case lists:keysearch(W,2,ClassFields) of
-	false ->
-	    throw({asn1,{optional_matcherror,WorS,W}});
-	{value,CField} ->
-	    {NewField,RestFields} = 
-		convert_to_defaultfield(S,W,[WorS|Rest],CField),
-	    match_optional_field(S,RestFields,Ws,ClassFields,[NewField|Ret])
+match_syntax(S, [{optional,L}|T], As0, Acc)         ->
+    case match_syntax(S, L, As0, []) of
+	{match,Match,As} ->
+	    match_syntax(S, T, As, lists:reverse(Match)++Acc);
+	{nomatch,As0} ->
+	    match_syntax(S, T, As0, Acc);
+	{nomatch,_}=NoMatch ->
+	    NoMatch
     end;
-match_optional_field(_S,[WorS|_Rest],[W|_Ws],_ClassFields,_Ret) ->
-    throw({asn1,{optional_matcherror,WorS,W}}).
-
-match_mandatory_field(_S,[],[],_,[Acc]) ->
-    {Acc,[],[]};
-match_mandatory_field(_S,[],[],_,Acc) ->
-    {Acc,[],[]};
-match_mandatory_field(S,[],[H|T],CF,Acc) when is_list(H) ->
-    match_mandatory_field(S,[],T,CF,Acc);
-match_mandatory_field(_S,[],WithSyntax,_,_Acc) ->
-    throw({asn1,{mandatory_matcherror,[],WithSyntax}});
-%match_mandatory_field(_S,Fields,WithSyntax=[W|_Ws],_ClassFields,[Acc]) when is_list(W) ->
-match_mandatory_field(_S,Fields,WithSyntax=[W|_Ws],_ClassFields,Acc) when is_list(W), length(Acc) >= 1 ->
-    {Acc,Fields,WithSyntax};
-%% identify and skip word
-%%match_mandatory_field(S,[{_,_,WorS}|Rest],
-match_mandatory_field(S,[{_,_,#'Externaltypereference'{type=WorS}}|Rest],
-		      [WorS|Ws],ClassFields,Acc) ->
-    match_mandatory_field(S,Rest,Ws,ClassFields,Acc);
-%% identify and skip comma
-match_mandatory_field(S,[{WorS,_}|Rest],[{WorS,_}|Ws],ClassFields,Ret) ->
-    match_mandatory_field(S,Rest,Ws,ClassFields,Ret);
-%% identify and save field data
-match_mandatory_field(S,[Setting|Rest],[{_,W}|Ws],ClassFields,Acc) ->
-    ?dbg("matching field setting: ~p with user friendly syntax: ~p~n",[Setting,W]),
-    WorS = 
-	case Setting of
-	    {object,_,_} -> Setting;
-	    {_,_,WordOrSetting} -> WordOrSetting;
-	    Type when is_record(Type,type) -> Type;
-	    Other -> Other
-	end,
-    case lists:keysearch(W,2,ClassFields) of
-	false ->
-	    throw({asn1,{mandatory_matcherror,WorS,W}});
-	{value,CField} ->
-	    {NewField,RestFields} = 
-		convert_to_defaultfield(S,W,[WorS|Rest],CField),
-	    match_mandatory_field(S,RestFields,Ws,ClassFields,[NewField|Acc])
+match_syntax(_, [_|_], [], _Acc)                    ->
+    {nomatch,[]};
+match_syntax(_, [], As, Acc)                        ->
+    {match,Acc,As}.
+
+match_syntax_type(S, Type, {value_tag,Val})         ->
+    match_syntax_type(S, Type, Val);
+match_syntax_type(S, Type, {setting,_,Val})         ->
+    match_syntax_type(S, Type, Val);
+match_syntax_type(S, Type, {word_or_setting,_,Val}) ->
+    match_syntax_type(S, Type, Val);
+match_syntax_type(_S, _Type, {Atom,Line})
+  when is_atom(Atom), is_integer(Line) ->
+    throw(nomatch);
+match_syntax_type(S, {fixedtypevaluefield,Name,#type{}=T,_,_}=Type,
+		  #'Externalvaluereference'{}=ValRef0) ->
+    try get_referenced_type(S, ValRef0) of
+	{M,#valuedef{}=ValDef} ->
+	    match_syntax_type(update_state(S, M), Type, ValDef)
+    catch
+	throw:{error,_} ->
+	    ValRef = #valuedef{name=Name,
+			       type=T,
+			       value=ValRef0,
+			       module=S#state.mname},
+	    match_syntax_type(S, Type, ValRef)
     end;
- 	    
-match_mandatory_field(_S,[WorS|_Rest],[W|_Ws],_ClassFields,_Acc) ->
-    throw({asn1,{mandatory_matcherror,WorS,W}}).
-
-%% Converts a field of an object from defined syntax to default syntax
-%% A field may be a type, a fixed type value, an object, an objectset,
-%% 
-convert_to_defaultfield(S,ObjFieldName,[OFS|RestOFS],CField)->
-    ?dbg("convert field: ~p of type: ~p~n",[ObjFieldName,element(1,CField)]),
-    CurrMod = S#state.mname,
-    Strip_value_tag = 
-	fun({value_tag,ValueSetting}) -> ValueSetting;
-	   (VS) -> VS
-	end,
-    ObjFieldSetting = Strip_value_tag(OFS),
-    RestSettings = [Strip_value_tag(X)||X <- RestOFS],
-    case element(1,CField) of
-	typefield ->
-	    TypeDef=
-		case ObjFieldSetting of
-		    TypeRec when is_record(TypeRec,type) -> TypeRec#type.def;
-		    TDef when is_record(TDef,typedef) -> 
-			TDef#typedef{checked=true,
-				     typespec=check_type(S,TDef,
-							 TDef#typedef.typespec)};
-		    _ -> ObjFieldSetting
-		end,
-	    {Type,SettingsLeft} = 
-		if
-		    is_record(TypeDef,typedef) -> {TypeDef,RestSettings};
-		    is_record(TypeDef,'ObjectClassFieldType') ->
-			T=check_type(S,#typedef{typespec=ObjFieldSetting},ObjFieldSetting),
-			{oCFT_def(S,T),RestSettings};
-%			#typedef{checked=true,name=Name,typespec=IT};
-		    is_tuple(TypeDef), element(1,TypeDef) == pt  ->
-			%% this is an inlined type. If constructed
-			%% type save in data base
-			T=check_type(S,#typedef{typespec=ObjFieldSetting},ObjFieldSetting),
-			#'Externaltypereference'{type=PtName} = 
-			    element(2,TypeDef),
-			NameList = [PtName,S#state.tname],
-			NewName = list_to_atom(asn1ct_gen:list2name(NameList)),
-			NewTDef=#typedef{checked=true,name=NewName,
-					 typespec=T},
-			asn1_db:dbput(S#state.mname,NewName,NewTDef),
-			%%asn1ct_gen:insert_once(parameterized_objects,{NewName,type,NewTDef}),
-			insert_once(S,parameterized_objects,
-				    {NewName,type,NewTDef}),
-			{NewTDef,RestSettings};
-		    is_tuple(TypeDef), element(1,TypeDef)=='SelectionType'  ->
-			T=check_type(S,#typedef{typespec=ObjFieldSetting},
-				     ObjFieldSetting),
-			Name = type_name(S,T),
-			{#typedef{checked=true,name=Name,typespec=T},RestSettings};
-		    true ->
-			case asn1ct_gen:type(asn1ct_gen:get_inner(TypeDef)) of
-			    ERef = #'Externaltypereference'{module=CurrMod} ->
-				{RefMod,T} = get_referenced_type(S,ERef),
-				check_and_save(S,ERef#'Externaltypereference'{module=RefMod},T,RestSettings);
-
-			    ERef = #'Externaltypereference'{} ->
-				{RefMod,T} = get_referenced_type(S,ERef),
-				check_and_save(S,ERef#'Externaltypereference'{module=RefMod},T,RestSettings);
-			    Bif when Bif=={primitive,bif};Bif=={constructed,bif} ->
-				T = check_type(S,#typedef{typespec=ObjFieldSetting},
-					       ObjFieldSetting),
-				{#typedef{checked=true,name=Bif,typespec=T},RestSettings};
-			    _ ->
-				%this case should not happen any more
-				{Mod,T} = 
-				    get_referenced_type(S,#'Externaltypereference'{module=S#state.mname,type=ObjFieldSetting}),
-				case Mod of
-				    CurrMod ->
-					{T,RestSettings};
-				    ExtMod ->
-					#typedef{name=Name} = T,
-					{T#typedef{name={ExtMod,Name}},RestSettings}
-				end
-			end
-		end,
-	    {{ObjFieldName,Type},SettingsLeft};
-	fixedtypevaluefield ->
-	    case ObjFieldName of
-		Val when is_atom(Val) ->
-		    %% ObjFieldSetting can be a value,an objectidentifiervalue,
-		    %% an element in an enumeration or namednumberlist etc.
-		    ValRef =
-			case ObjFieldSetting of
-			    ValSetting=#'Externalvaluereference'{} ->
-				ValSetting;
-			    {'ValueFromObject',{_,ObjRef},FieldName} ->
-				{_,Object} = get_referenced_type(S,ObjRef),
-				ChObject = check_object(S,Object,
-							Object#typedef.typespec),
-				get_fieldname_element(S,Object#typedef{typespec=ChObject},
-						      FieldName);
-			    ValSetting = #valuedef{} ->
-				ValSetting;
-			    ValSetting = {'CHOICE',{Alt,_ChVal}} when is_atom(Alt) ->
-					#valuedef{type=element(3,CField),
-						  value=ValSetting,
-						  module=S#state.mname};
-			    ValSetting ->
-				#identifier{val=ValSetting}
-			end,
-		    ?dbg("fixedtypevaluefield ValRef: ~p~n",[ValRef]),
-		    case ValRef of
-			#valuedef{} ->
-			    {{ObjFieldName,check_value(S,ValRef)},RestSettings};
-			_ ->
-			    ValDef =
-				case catch get_referenced_type(S,ValRef) of
-				    {error,_} ->
-					NewValDef =
-					    #valuedef{name=Val,
-						      type=element(3,CField),
-						      value=ObjFieldSetting,
-						      module=S#state.mname},
-					check_value(S,NewValDef);
-				    {M,VDef} when is_record(VDef,valuedef) ->
-					check_value(update_state(S,M),
-						    %%S#state{mname=M},
-						    VDef);%% XXX
-				    {M,VDef} ->
-					check_value(update_state(S,M),
-						    %%S#state{mname=M},
-						    #valuedef{name=Val,
-							      type=element(3,CField),
-							      value=VDef,
-							      module=M})
-				end,
-			    {{ObjFieldName,ValDef},RestSettings}
-		    end;
-		Val ->
-		    {{ObjFieldName,Val},RestSettings}
-	    end;
-	fixedtypevaluesetfield ->
-	    {{ObjFieldName,ObjFieldSetting},RestSettings};
-	objectfield ->
-	    CheckObject = 
-		fun(O) ->
-			O#typedef{checked=true,typespec=
-				  check_object(S,O,O#typedef.typespec)}
-		end,
-	    ObjectSpec = 
-		case ObjFieldSetting of
-		    Ref when is_record(Ref,'Externalvaluereference') ->
-			%% The object O might be a #valuedef{} if
-			%% e.g. the definition looks like 
-			%% myobj SOMECLASS ::= referencedObject
-			{M,O} = get_referenced_type(S,Ref),
-			check_object(S,O,object_to_check(O)),
-			Ref#'Externalvaluereference'{module=M};
-
-		    {'ValueFromObject',{_,ObjRef},FieldName} ->
-			%% This is an ObjectFromObject
-			{_,Object} = get_referenced_type(S,ObjRef),
-			ChObject = check_object(S,Object,
-						Object#typedef.typespec),
-			ObjFromObj=
-			    get_fieldname_element(S,Object#typedef{
-						      typespec=ChObject},
-						  FieldName),
-			CheckObject(ObjFromObj);
-		    ObjDef={object,_,_} ->
-			%% An object defined inlined in another object
-			%% class is an objectfield, that implies that 
-			%% {objectsetfield,TypeFieldName,DefinedObjecClass,
-			%%  OptionalitySpec}
-			%% DefinedObjecClass = #'Externaltypereference'{}|
-			%% 'TYPE-IDENTIFIER' | 'ABSTRACT-SYNTAX'
-			ClassName = element(3,CField),
-			InlinedObjName=
-			    list_to_atom(lists:concat([S#state.tname]++
-						      ['_',ObjFieldName])),
-
-			ObjSpec = #'Object'{classname=ClassName,
-					    def=ObjDef},
-			CheckedObj=
-			    check_object(S,#typedef{typespec=ObjSpec},ObjSpec),
-			InlObj = #typedef{checked=true,name=InlinedObjName,
-					  typespec=CheckedObj},
-			ObjKey = {InlinedObjName,InlinedObjName},
-			%% asn1ct_gen:insert_once(inlined_objects,ObjKey),
-			insert_once(S,inlined_objects,ObjKey),
-			%% Which module to use here? Could it be other than top_module ?
-			%% asn1_db:dbput(S#state.mname,InlinedObjName,InlObj),
-			asn1_db:dbput(get(top_module),InlinedObjName,InlObj),
-			InlObj;
-		    #type{def=Eref} when is_record(Eref,'Externaltypereference') ->
-			{_,O} = get_referenced_type(S,Eref),
-			CheckObject(O);
-		    Other ->
-			{_,O} = get_referenced_type(S,#'Externaltypereference'{module=S#state.mname,type=Other}),
-			CheckObject(O)
-		end,
-	    {{ObjFieldName,ObjectSpec},RestSettings};
-	variabletypevaluefield ->
-	    {{ObjFieldName,ObjFieldSetting},RestSettings};
-	variabletypevaluesetfield ->
-	    {{ObjFieldName,ObjFieldSetting},RestSettings};
-%% 	objectset_or_fixedtypevalueset_field ->
-%% 	    ok;
-	objectsetfield ->
-	    ObjSetSpec = get_objectset_def(S,ObjFieldSetting,CField),
-	    ?dbg("objectsetfield, ObjSetSpec:~p~n",[ObjSetSpec]),
-	    {{ObjFieldName,
-	      ObjSetSpec#typedef{checked=true,
-				 typespec=check_object(S,ObjSetSpec,
-						       ObjSetSpec#typedef.typespec)}},RestSettings}
+match_syntax_type(S, {fixedtypevaluefield,Name,#type{},_,_}, #valuedef{}=Val0) ->
+    Val = check_value(S, Val0),
+    {match,[{Name,Val}]};
+match_syntax_type(S, {fixedtypevaluefield,Name,#type{},_,_},
+		  {'ValueFromObject',{object,Object},FieldNames}) ->
+    Val = extract_field(S, Object, FieldNames),
+    {match,[{Name,Val}]};
+match_syntax_type(S, {fixedtypevaluefield,Name,#type{}=T,_,_}=Type, Any) ->
+    ValDef = #valuedef{name=Name,type=T,value=Any,module=S#state.mname},
+    match_syntax_type(S, Type, ValDef);
+match_syntax_type(_S, {fixedtypevaluesetfield,Name,#type{},_}, Any) ->
+    {match,[{Name,Any}]};
+match_syntax_type(S, {objectfield,Name,_,_,_}, #'Externalvaluereference'{}=Ref) ->
+    {M,Obj} = get_referenced_type(S, Ref),
+    check_object(S, Obj, object_to_check(S, Obj)),
+    {match,[{Name,Ref#'Externalvaluereference'{module=M}}]};
+match_syntax_type(S, {objectfield,Name,Class,_,_}, {object,_,_}=ObjDef) ->
+    InlinedObjName = list_to_atom(lists:concat([S#state.tname,
+						'_',Name])),
+    ObjSpec = #'Object'{classname=Class,def=ObjDef},
+    CheckedObj = check_object(S, #typedef{typespec=ObjSpec}, ObjSpec),
+    InlObj = #typedef{checked=true,name=InlinedObjName,typespec=CheckedObj},
+    ObjKey = {InlinedObjName, InlinedObjName},
+    insert_once(S, inlined_objects, ObjKey),
+    %% Which module to use here? Could it be other than top_module?
+    asn1_db:dbput(get(top_module), InlinedObjName, InlObj),
+    {match,[{Name,InlObj}]};
+match_syntax_type(_S, {objectfield,Name,_,_,_}, Any) ->
+    {match,[{Name,Any}]};
+match_syntax_type(S, {objectsetfield,Name,CDef0,_}, Any) ->
+    CDef = case CDef0 of
+	       #type{def=CDef1} -> CDef1;
+	       CDef1 -> CDef1
+	   end,
+    case match_syntax_objset(S, Any, CDef) of
+	#typedef{typespec=#'ObjectSet'{}=Ts0}=Def ->
+	    Ts = check_object(S, Def, Ts0),
+	    {match,[{Name,Def#typedef{checked=true,typespec=Ts}}]};
+	_ ->
+	    syntax_match_error(S, Any)
+    end;
+match_syntax_type(S, {typefield,Name0,_}, #type{def={pt,_,_}=Def}=Actual) ->
+    %% This is an inlined type. If constructed type, save in data base.
+    T = check_type(S, #typedef{typespec=Actual}, Actual),
+    #'Externaltypereference'{type=PtName} = element(2, Def),
+    NameList = [PtName,S#state.tname],
+    Name = list_to_atom(asn1ct_gen:list2name(NameList)),
+    NewTDef = #typedef{checked=true,name=Name,typespec=T},
+    asn1_db:dbput(S#state.mname, Name, NewTDef),
+    insert_once(S, parameterized_objects, {Name,type,NewTDef}),
+    {match,[{Name0,NewTDef}]};
+match_syntax_type(S, {typefield,Name,_}, #type{def=#'ObjectClassFieldType'{}}=Actual) ->
+    T = check_type(S, #typedef{typespec=Actual}, Actual),
+    {match,[{Name,ocft_def(T)}]};
+match_syntax_type(S, {typefield,Name,_}, #type{def=#'Externaltypereference'{}=Ref}) ->
+    match_syntax_external(S, Name, Ref);
+match_syntax_type(S, {typefield,Name,_}, #type{def=Def}=Actual) ->
+    T = check_type(S, #typedef{typespec=Actual}, Actual),
+    TypeName = asn1ct_gen:type(asn1ct_gen:get_inner(Def)),
+    {match,[{Name,#typedef{checked=true,name=TypeName,typespec=T}}]};
+match_syntax_type(S, {typefield,Name,_}, #'Externaltypereference'{}=Ref) ->
+    match_syntax_external(S, Name, Ref);
+match_syntax_type(_S, {variabletypevaluefield,Name,_,_}, Any) ->
+    {match,[{Name,Any}]};
+match_syntax_type(_S, {variabletypevaluesetfield,Name,_,_}, Any) ->
+    {match,[{Name,Any}]};
+match_syntax_type(_S, _Type, _Actual) ->
+    throw(nomatch).
+
+match_syntax_params(S0, #ptypedef{name=Name}=PtDef,
+		    #'Externaltypereference'{module=M,type=N}=ERef0, Args) ->
+    S = S0#state{mname=M,module=load_asn1_module(S0, M),tname=Name},
+    Type = check_type(S, PtDef, #type{def={pt,ERef0,Args}}),
+    ERefName = new_reference_name(N),
+    ERef = #'Externaltypereference'{type=ERefName,module=S0#state.mname},
+    TDef = #typedef{checked=true,name=ERefName,typespec=Type},
+    insert_once(S0, parameterized_objects, {ERefName,type,TDef}),
+    asn1_db:dbput(S0#state.mname, ERef#'Externaltypereference'.type, TDef),
+    ERef.
+
+match_syntax_external(#state{mname=Mname}=S0, Name, Ref0) ->
+    {M,T0} = get_referenced_type(S0, Ref0),
+    Ref1 = Ref0#'Externaltypereference'{module=M},
+    case T0 of
+	#ptypedef{} ->
+	    {params,Name,T0,Ref1};
+	#typedef{checked=false}=TDef0 when Mname =/= M  ->
+	    %% This typedef is an imported type (or maybe a set.asn
+	    %% compilation).
+	    S = S0#state{mname=M,module=load_asn1_module(S0, M),
+			 tname=get_datastr_name(TDef0)},
+	    Type = check_type(S, TDef0, TDef0#typedef.typespec),
+	    TDef = TDef0#typedef{checked=true,typespec=Type},
+	    asn1_db:dbput(M, get_datastr_name(TDef), TDef),
+	    {match,[{Name,merged_name(S, Ref1)}]};
+	TDef ->
+	    %% This might be a renamed type in a set of specs,
+	    %% so rename the ref.
+	    Type = asn1ct:get_name_of_def(TDef),
+	    Ref = Ref1#'Externaltypereference'{type=Type},
+	    {match,[{Name,Ref}]}
     end.
 
-get_objectset_def(S,Ref,CField)
-  when is_record(Ref,'Externaltypereference');
-       is_record(Ref,'Externalvaluereference') ->
-    {_M,T}=get_referenced_type(S,Ref),
-    get_objectset_def2(S,T,CField);
-get_objectset_def(S,ObjectList,CField) when is_list(ObjectList) ->
-    %% an objctset defined in the object,though maybe
-    %% parsed as a SequenceOfValue 
-    %% The ObjectList may be a list of references to
-    %% objects, a ValueFromObject
-    ?dbg("objectsetfield: ~p~n",[CField]),
-    get_objectset_def2(S,ObjectList,CField);
-get_objectset_def(S,'EXTENSIONMARK',CField) ->
-    ?dbg("objectsetfield: ~p~n",[CField]),
-    get_objectset_def2(S,['EXTENSIONMARK'],CField);
-get_objectset_def(_S,ObjFieldSetting={'SingleValue',_},CField) ->
-    %% a Union of defined objects
-    ?dbg("objectsetfield, SingleValue~n",[]),
-    union_of_defed_objs(CField,ObjFieldSetting);
-get_objectset_def(_S,ObjFieldSetting={{'SingleValue',_},_},CField) ->
-    %% a Union of defined objects
-    ?dbg("objectsetfield, SingleValue~n",[]),
-    union_of_defed_objs(CField,ObjFieldSetting);
-get_objectset_def(S,{object,_,[#type{def={'TypeFromObject',
-					  {object,RefedObj},
-					  FieldName}}]},_CField) ->
-    %% This case occurs when an ObjectSetFromObjects 
-    %% production is used
-    {_M,Def} = get_referenced_type(S,RefedObj),
-    get_fieldname_element(S,Def,FieldName);
-get_objectset_def(S,{object,_,[{setting,_,ERef}]},CField)
-  when is_record(ERef,'Externaltypereference') ->
-    {_,T} = get_referenced_type(S,ERef),
-    get_objectset_def2(S,T,CField);
-get_objectset_def(S,#type{def=ERef},_CField) 
-  when is_record(ERef,'Externaltypereference') ->
-    {_,T} = get_referenced_type(S,ERef),
+match_syntax_objset(_S, {element_set,_,_}=Set, ClassDef) ->
+    make_objset(ClassDef, Set);
+match_syntax_objset(S, #'Externaltypereference'{}=Ref, _) ->
+    {_,T} = get_referenced_type(S, Ref),
     T;
-get_objectset_def(S,ObjFieldSetting,CField)
-  when is_atom(ObjFieldSetting) ->
-    ERef = #'Externaltypereference'{module=S#state.mname,
-				    type=ObjFieldSetting},
-    {_,T} = get_referenced_type(S,ERef),
-    get_objectset_def2(S,T,CField).
-
-get_objectset_def2(_S,T = #typedef{typespec=#'Object'{}},_CField) ->
-    #typedef{typespec=#'Object'{classname=Class,def=Def}} = T,
-    T#typedef{typespec=#'ObjectSet'{class=Class,set=[Def]}};
-get_objectset_def2(_S,Set,CField) when is_list(Set) ->
-    {_,_,Type,_} = CField,
-    ClassDef = Type#type.def,
-    #typedef{typespec=#'ObjectSet'{class=ClassDef,
-				   set=Set}};
-get_objectset_def2(_S,T = #typedef{typespec=#'ObjectSet'{}},_CField) ->
+match_syntax_objset(S, #'Externalvaluereference'{}=Ref, _) ->
+    {_,T} = get_referenced_type(S, Ref),
     T;
-get_objectset_def2(S,T,_CField) ->
-    asn1ct:warning("get_objectset_def2: uncontrolled object set structure:~n~p~n",
-		   [T],S,"get_objectset_def2: uncontrolled object set structure").
-    
-type_name(S,#type{def=Def}) ->
-    CurrMod = S#state.mname,
-    case asn1ct_gen:type(asn1ct_gen:get_inner(Def)) of
-	#'Externaltypereference'{module=CurrMod,type=Name} ->
-	    Name;
-	#'Externaltypereference'{module=Mod,type=Name} ->
-	    {Mod,Name};
-	Bif when Bif=={primitive,bif};Bif=={constructed,bif} ->
-	    Bif
+match_syntax_objset(_, [_|_]=Set, ClassDef) ->
+    make_objset(ClassDef, Set);
+match_syntax_objset(S, {object,definedsyntax,Words}, ClassDef) ->
+    case Words of
+	[Word] ->
+	    match_syntax_objset_1(S, Word, ClassDef);
+	[_|_] ->
+	    %% More than one word does not make sense.
+	    none
+    end;
+match_syntax_objset(S, #type{def=#'Externaltypereference'{}=Set}, ClassDef) ->
+    match_syntax_objset(S, Set, ClassDef);
+match_syntax_objset(_, #type{}, _) ->
+    none.
+
+match_syntax_objset_1(S, {setting,_,Set}, ClassDef) ->
+    %% Word that starts with an uppercase letter.
+    match_syntax_objset(S, Set, ClassDef);
+match_syntax_objset_1(S, {word_or_setting,_,Set}, ClassDef) ->
+    %% Word in uppercase/hyphens only.
+    match_syntax_objset(S, Set, ClassDef);
+match_syntax_objset_1(S, #type{def={'TypeFromObject', {object,Object}, FNs}},
+		      ClassDef) ->
+    Set = extract_field(S, Object, FNs),
+    [_|_] = Set,
+    #typedef{checked=true,typespec=#'ObjectSet'{class=ClassDef,set=Set}};
+match_syntax_objset_1(_, #type{def=#'ObjectClassFieldType'{}}=Set, ClassDef) ->
+    make_objset(ClassDef, Set);
+match_syntax_objset_1(_, {object,_,_}=Object, ClassDef) ->
+    make_objset(ClassDef, [Object]).
+
+make_objset(ClassDef, Set) ->
+    #typedef{typespec=#'ObjectSet'{class=ClassDef,set=Set}}.
+
+-spec syntax_match_error(_) -> no_return().
+syntax_match_error(S) ->
+    asn1_error(S, syntax_nomatch).
+
+-spec syntax_match_error(_, _) -> no_return().
+syntax_match_error(S, What0) ->
+    What = printable_string(What0),
+    asn1_error(S, {syntax_nomatch,What}).
+
+printable_string(Def) ->
+    printable_string_1(Def).
+
+printable_string_1({word_or_setting,_,Def}) ->
+    printable_string_1(Def);
+printable_string_1({value_tag,V}) ->
+    printable_string_1(V);
+printable_string_1({#seqtag{val=Val1},Val2}) ->
+    atom_to_list(Val1) ++ " " ++ printable_string_1(Val2);
+printable_string_1(#type{def=Def}) ->
+    atom_to_list(asn1ct_gen:get_inner(Def));
+printable_string_1(#'Externaltypereference'{type=Type}) ->
+    atom_to_list(Type);
+printable_string_1(#'Externalvaluereference'{value=Type}) ->
+    atom_to_list(Type);
+printable_string_1({Atom,Line}) when is_atom(Atom), is_integer(Line) ->
+    q(Atom);
+printable_string_1({object,definedsyntax,L}) ->
+    q(string:join([printable_string_1(Item) || Item <- L], " "));
+printable_string_1([_|_]=Def) ->
+    case lists:all(fun is_integer/1, Def) of
+	true ->
+	    lists:flatten(io_lib:format("~p", [Def]));
+	false ->
+	    q(string:join([printable_string_1(Item) || Item <- Def], " "))
+    end;
+printable_string_1(Def) ->
+    lists:flatten(io_lib:format("~p", [Def])).
+
+q(S) ->
+    lists:concat(["\"",S,"\""]).
+
+check_defaultfields(S, Fields, ClassFields) ->
+    Present = ordsets:from_list([F || {F,_} <- Fields]),
+    Mandatory0 = get_mandatory_class_fields(ClassFields),
+    Mandatory = ordsets:from_list(Mandatory0),
+    All = ordsets:from_list([element(2, F) || F <- ClassFields]),
+    #state{tname=Obj} = S,
+    case ordsets:subtract(Present, All) of
+	[] ->
+	    ok;
+	[_|_]=Invalid ->
+	    asn1_error(S, {invalid_fields,Invalid,Obj})
+    end,
+    case ordsets:subtract(Mandatory, Present) of
+	[] ->
+	    check_defaultfields_1(S, Fields, ClassFields, []);
+	[_|_]=Missing ->
+	    asn1_error(S, {missing_mandatory_fields,Missing,Obj})
     end.
 
+check_defaultfields_1(_S, [], _ClassFields, Acc) ->
+    {object,defaultsyntax,lists:reverse(Acc)};
+check_defaultfields_1(S, [{FName,Spec}|Fields], ClassFields, Acc) ->
+    CField = lists:keyfind(FName, 2, ClassFields),
+    {match,Match} = match_syntax_type(S, CField, Spec),
+    check_defaultfields_1(S, Fields, ClassFields, Match++Acc).
+
+get_mandatory_class_fields(ClassFields) ->
+    [element(2, F) || F <- ClassFields,
+		      is_mandatory_class_field(F)].
+
+is_mandatory_class_field({fixedtypevaluefield,_,_,_,'MANDATORY'}) ->
+    true;
+is_mandatory_class_field({objectfield,_,_,_,'MANDATORY'}) ->
+    true;
+is_mandatory_class_field({objectsetfield,_,_,'MANDATORY'}) ->
+    true;
+is_mandatory_class_field({typefield,_,'MANDATORY'}) ->
+    true;
+is_mandatory_class_field({variabletypevaluefield,_,_,'MANDATORY'}) ->
+    true;
+is_mandatory_class_field({variabletypevaluesetfield,_,_,'MANDATORY'}) ->
+    true;
+is_mandatory_class_field(_) ->
+    false.
+
 merged_name(#state{inputmodules=[]},ERef) ->
     ERef;
 merged_name(S,ERef=#'Externaltypereference'{module=M}) ->
@@ -1989,38 +1652,18 @@ merged_name(S,ERef=#'Externaltypereference'{module=M}) ->
 	    ERef
     end.
 
-oCFT_def(S,T) ->
-    case get_OCFT_inner(S,T) of
-	ERef=#'Externaltypereference'{} -> ERef;
-	{Name,Type} -> #typedef{checked=true,name=Name,typespec=Type};
-	'ASN1_OPEN_TYPE' -> 
-	    #typedef{checked=true,typespec=T#type{def='ASN1_OPEN_TYPE'}}
-    end.
-	    
-get_OCFT_inner(_S,T) ->
-%    Module=S#state.mname,
-    Def = T#type.def,
-    case Def#'ObjectClassFieldType'.type of
+ocft_def(#type{def=#'ObjectClassFieldType'{type=OCFT}}=T) ->
+    case OCFT of
 	{fixedtypevaluefield,_,InnerType} ->
 	    case asn1ct_gen:type(asn1ct_gen:get_inner(InnerType#type.def)) of
-		Bif when Bif=={primitive,bif};Bif=={constructed,bif} ->
-		    {Bif,InnerType};
-		ERef = #'Externaltypereference'{} ->
-		    ERef
+		Bif when Bif =:= {primitive,bif}; Bif =:= {constructed,bif} ->
+		    #typedef{checked=true,name=Bif,typespec=InnerType};
+		#'Externaltypereference'{}=Ref ->
+		    Ref
 	    end;
-	'ASN1_OPEN_TYPE' -> 'ASN1_OPEN_TYPE'
+	'ASN1_OPEN_TYPE' ->
+	    #typedef{checked=true,typespec=T#type{def='ASN1_OPEN_TYPE'}}
     end.
-	    
-	
-	
-union_of_defed_objs({_,_,_ObjClass=#type{def=ClassDef},_},ObjFieldSetting) -> 
-    #typedef{typespec=#'ObjectSet'{class = ClassDef,
-				   set = ObjFieldSetting}};
-union_of_defed_objs({_,_,DefObjClassRef,_},ObjFieldSetting)
-  when is_record(DefObjClassRef,'Externaltypereference') ->
-    #typedef{typespec=#'ObjectSet'{class = DefObjClassRef,
-				   set = ObjFieldSetting}}.
-    
 
 check_value(OldS,V) when is_record(V,pvaluesetdef) ->
     #pvaluesetdef{checked=Checked,type=Type} = V,
@@ -2044,8 +1687,7 @@ check_value(OldS,V) when is_record(V,typedef) ->
     #typedef{typespec=TS} = V,
     case TS of 
 	#'ObjectSet'{class=ClassRef} ->
-	    {RefM,TSDef} = get_referenced_type(OldS,ClassRef),
-	    %%IsObjectSet(TSDef);
+	    {_RefM,TSDef} = get_referenced_type(OldS, ClassRef),
 	    case TSDef of
 		#classdef{} -> throw({objectsetdef});
 		#typedef{typespec=#type{def=Eref}} when 
@@ -2053,14 +1695,12 @@ check_value(OldS,V) when is_record(V,typedef) ->
 		    %% This case if the class reference is a defined
 		    %% reference to class
 		    check_value(OldS,V#typedef{typespec=TS#'ObjectSet'{class=Eref}});
-		#typedef{} ->
+		#typedef{typespec=HostType} ->
 		    % an ordinary value set with a type in #typedef.typespec
-		    ValueSet = TS#'ObjectSet'.set,
-		    Type=check_type(OldS,TSDef,TSDef#typedef.typespec),
-		    Value = check_value(OldS,#valuedef{type=Type,
-						       value=ValueSet,
-						       module=RefM}),
-		    {valueset,Type#type{constraint=Value#valuedef.value}}
+		    ValueSet0 = TS#'ObjectSet'.set,
+		    Constr = check_constraints(OldS, HostType, [ValueSet0]),
+		    Type = check_type(OldS,TSDef,TSDef#typedef.typespec),
+		    {valueset,Type#type{constraint=Constr}}
 	    end;
 	_ ->
 	    throw({objectsetdef})
@@ -2080,11 +1720,11 @@ check_value(S, #valuedef{}=V) ->
     end.
 
 check_valuedef(#state{recordtopname=TopName}=S0, V0) ->
-    #valuedef{name=Name,type=Vtype,value=Value,module=ModName} = V0,
+    #valuedef{name=Name,type=Vtype0,value=Value,module=ModName} = V0,
     V = V0#valuedef{checked=true},
+    Vtype = check_type(S0, #typedef{name=Name,typespec=Vtype0},Vtype0),
     Def = Vtype#type.def,
-    Constr = Vtype#type.constraint,
-    S1 = S0#state{type=Vtype,tname=Def,value=V0,vname=Name},
+    S1 = S0#state{tname=Def},
     SVal = update_state(S1, ModName),
     case Def of
 	#'Externaltypereference'{type=RecName}=Ext ->
@@ -2092,9 +1732,8 @@ check_valuedef(#state{recordtopname=TopName}=S0, V0) ->
 	    %% If V isn't a value but an object Type is a #classdef{}
 	    S2 = update_state(S1, RefM),
 	    case Type of
-		#classdef{} ->
-		    throw({objectdef});
-		#typedef{typespec=TypeSpec} ->
+		#typedef{typespec=TypeSpec0}=TypeDef ->
+		    TypeSpec = check_type(S2, TypeDef, TypeSpec0),
 		    S3 = case is_contextswitchtype(Type) of
 			     true ->
 				 S2;
@@ -2111,7 +1750,7 @@ check_valuedef(#state{recordtopname=TopName}=S0, V0) ->
 				    V#valuedef{type=Type}),
 		    V#valuedef{value=CheckedVal}
 	    end;
-	'ANY' ->
+	'ASN1_OPEN_TYPE' ->
 	    {opentypefieldvalue,ANYType,ANYValue} = Value,
 	    CheckedV = check_value(SVal,#valuedef{name=Name,
 						  type=ANYType,
@@ -2119,21 +1758,12 @@ check_valuedef(#state{recordtopname=TopName}=S0, V0) ->
 						  module=ModName}),
 	    V#valuedef{value=CheckedV#valuedef.value};
 	'INTEGER' ->
-	    ok = validate_integer(SVal, Value, [], Constr),
 	    V#valuedef{value=normalize_value(SVal, Vtype, Value, [])};
-	{'INTEGER',NamedNumberList} ->
-	    ok = validate_integer(SVal, Value, NamedNumberList, Constr),
+	{'INTEGER',_NamedNumberList} ->
 	    V#valuedef{value=normalize_value(SVal, Vtype, Value, [])};
-	#'SEQUENCE'{components=Components} ->
-	    {ok,SeqVal} = validate_sequence(SVal, Value,
-					    Components, Constr),
-	    V#valuedef{value=normalize_value(SVal, Vtype,
-					    SeqVal, TopName)};
-	{'SelectionType',SelName,SelT} ->
-	    CheckedT = check_selectiontype(SVal, SelName, SelT),
-	    NewV = V#valuedef{type=CheckedT},
-	    SelVDef = check_value(S1#state{value=NewV}, NewV),
-	    V#valuedef{value=SelVDef#valuedef.value};
+	#'SEQUENCE'{} ->
+	    {ok,SeqVal} = convert_external(SVal, Vtype, Value),
+	    V#valuedef{value=normalize_value(SVal, Vtype, SeqVal, TopName)};
 	_ ->
 	    V#valuedef{value=normalize_value(SVal, Vtype, Value, TopName)}
     end.
@@ -2147,178 +1777,97 @@ is_contextswitchtype(#typedef{name='CHARACTER STRING'}) ->
 is_contextswitchtype(_) ->
     false.
 
-% validate_integer(S,{identifier,Pos,Id},NamedNumberList,Constr) ->
-%     case lists:keysearch(Id,1,NamedNumberList) of
-% 	{value,_} -> ok;
-% 	false -> error({value,"unknown NamedNumber",S})
-%     end;
-%% This case occurs when there is a valuereference
-%% validate_integer(S=#state{mname=M},
-%% 		 #'Externalvaluereference'{module=M,value=Id}=Ref,
-validate_integer(S,#'Externalvaluereference'{value=Id}=Ref,
-		 NamedNumberList,Constr) ->
-    case lists:keysearch(Id,1,NamedNumberList) of
-	{value,_} -> ok;
-	false -> validate_integer_ref(S,Ref,NamedNumberList,Constr)
-	    %%error({value,"unknown NamedNumber",S})
-    end;
-validate_integer(S,Id,NamedNumberList,Constr) when is_atom(Id) ->
-    case lists:keysearch(Id,1,NamedNumberList) of
-	{value,_} -> ok;
-	false -> validate_integer_ref(S,Id,NamedNumberList,Constr)
-		     %error({value,"unknown NamedNumber",S})
+%%%
+%%% Start of OBJECT IDENTFIER/RELATIVE-OID validation.
+%%%
+
+validate_objectidentifier(S, OidType, #'Externalvaluereference'{}=Id) ->
+    %% Must be an OBJECT IDENTIFIER or RELATIVE-OID depending on OidType.
+    get_oid_value(S, OidType, false, Id);
+validate_objectidentifier(S, OidType, {'ValueFromObject',{object,Obj},Fields}) ->
+    %% Must be an OBJECT IDENTIFIER/RELATIVE-OID depending on OidType.
+    case extract_field(S, Obj, Fields) of
+	#valuedef{checked=true,value=Value,type=Type} when is_tuple(Value) ->
+	    _ = get_oid_type(S, OidType, Type),
+	    Value;
+	_ ->
+	    asn1_error(S, {illegal_oid,OidType})
     end;
-validate_integer(_S,Value,_NamedNumberList,Constr) when is_integer(Value) ->
-    check_integer_range(Value,Constr).
-
-validate_integer_ref(S,Id,_,_) when is_atom(Id) ->
-    error({value,"unknown integer referens",S});
-validate_integer_ref(S,Ref,NamedNumberList,Constr) ->
-    case get_referenced_type(S,Ref) of
-	{M,V} when is_record(V,valuedef) -> 
-	    NewS = update_state(S,M),
-	    case check_value(NewS,V) of
-		#valuedef{type=#type{def='INTEGER'},value=Value} ->
-		    validate_integer(NewS,Value,NamedNumberList,Constr);
-		_Err -> error({value,"unknown integer referens",S})
+validate_objectidentifier(S, OidType,
+			  [{#seqtag{module=Mod,pos=Pos,val=Atom},Val}]) ->
+    %% This case is when an OBJECT IDENTIFIER value has been parsed as a
+    %% SEQUENCE value.
+    Rec = #'Externalvaluereference'{pos=Pos,
+				    module=Mod,
+				    value=Atom},
+    validate_oid(S, OidType, [Rec,Val], []);
+validate_objectidentifier(S, OidType, [_|_]=L0) ->
+    validate_oid(S, OidType, L0, []);
+validate_objectidentifier(S, OidType, _) ->
+    asn1_error(S, {illegal_oid,OidType}).
+
+get_oid_value(S, OidType, AllowInteger, #'Externalvaluereference'{}=Id) ->
+    case get_referenced_type(S, Id) of
+	{_,#valuedef{checked=Checked,type=Type,value=V}} ->
+	    case get_oid_type(S, OidType, Type) of
+		'INTEGER' when not AllowInteger ->
+		    asn1_error(S, {illegal_oid,OidType});
+		_ when Checked ->
+		    V;
+		'INTEGER' ->
+		    V;
+		_ ->
+		    validate_objectidentifier(S, OidType, V)
 	    end;
 	_ ->
-	    error({value,"unknown integer referens",S})
-    end.
-	    
-		
-
-check_integer_range(_Int, Constr) when is_list(Constr) ->
-    ok.
-
-%%------------
-%% This can be removed when the old parser is removed
-%% The function removes 'space' atoms from the list
-
-is_space_list([H],Acc) ->
-    lists:reverse([H|Acc]);
-is_space_list([H,space|T],Acc) ->
-    is_space_list(T,[H|Acc]);
-is_space_list([],Acc) ->
-    lists:reverse(Acc);
-is_space_list([H|T],Acc) ->
-    is_space_list(T,[H|Acc]).
-
-validate_objectidentifier(S,OID,ERef,C) 
-  when is_record(ERef,'Externalvaluereference') ->
-    validate_objectidentifier(S,OID,[ERef],C);
-validate_objectidentifier(S,OID,Tup,C) when is_tuple(Tup) ->
-    validate_objectidentifier(S,OID,tuple_to_list(Tup),C);
-validate_objectidentifier(S,OID,L,_) ->
-    NewL = is_space_list(L,[]),
-    case validate_objectidentifier1(S,OID,NewL) of
-	NewL2 when is_list(NewL2) ->{ok,list_to_tuple(NewL2)};
-	Other -> {ok,Other}
+	    asn1_error(S, {illegal_oid,OidType})
     end.
 
-validate_objectidentifier1(S, OID, [Id|T])
-  when is_record(Id,'Externalvaluereference') ->
-    case catch get_referenced_type(S,Id) of
-	{M,V} when is_record(V,valuedef) -> 
-	    NewS = update_state(S,M),
-	    case check_value(NewS,V) of
-		#valuedef{type=#type{def=ERef},checked=true,
-			  value=Value} when is_tuple(Value) ->
-		    case is_object_id(OID,NewS,ERef) of 
-			true ->
-			    %% T must be a RELATIVE-OID
-			    validate_oid(true,NewS, rel_oid, T, lists:reverse(tuple_to_list(Value)));
-			_ ->
-			    error({value, {"illegal "++to_string(OID),[Id|T]}, S})
-		    end;
-		_ -> 
-		    error({value, {"illegal "++to_string(OID),[Id|T]}, S})
-	    end;
-	_ ->
-	    validate_oid(true,S, OID, [Id|T], [])
-    end;
-validate_objectidentifier1(S,OID,V) ->
-    validate_oid(true,S,OID,V,[]).
-
-validate_oid(false, S, OID, V, Acc) ->
-    error({value, {"illegal "++to_string(OID), V,Acc}, S});
-validate_oid(_,_, _, [], Acc) ->
-    lists:reverse(Acc);
-validate_oid(_, S, OID, [Value|Vrest], Acc) when is_integer(Value) ->
-    validate_oid(valid_objectid(OID,Value,Acc),S, OID, Vrest, [Value|Acc]);
-validate_oid(_, S, OID, [{'NamedNumber',_Name,Value}|Vrest], Acc) 
+validate_oid(S, OidType, [], Acc) ->
+    Oid = lists:reverse(Acc),
+    validate_oid_path(S, OidType, Oid),
+    list_to_tuple(Oid);
+validate_oid(S, OidType, [Value|Vrest], Acc) when is_integer(Value) ->
+    validate_oid(S, OidType, Vrest, [Value|Acc]);
+validate_oid(S, OidType, [{'NamedNumber',_Name,Value}|Vrest], Acc)
   when is_integer(Value) ->
-    validate_oid(valid_objectid(OID,Value,Acc), S, OID, Vrest, [Value|Acc]);
-validate_oid(_, S, OID, [Id|Vrest], Acc) 
-  when is_record(Id,'Externalvaluereference') ->
-    case catch get_referenced_type(S, Id) of
-	{M,V} when is_record(V,valuedef) ->
-	    NewS = update_state(S,M),
-	    NewVal = case check_value(NewS, V) of
-			 #valuedef{checked=true,value=Value} ->
-			     fun(Int) when is_integer(Int) ->  [Int];
-				(L) when is_list(L) -> L;
-				(T) when is_tuple(T) -> tuple_to_list(T)
-			     end (Value);
-			 _ ->
-			     error({value, {"illegal "++to_string(OID),
-					    [Id|Vrest],Acc}, S})
-		     end,
-	    case NewVal of
-		List when is_list(List) ->
-		    validate_oid(valid_objectid(OID,NewVal,Acc), NewS, 
-				 OID, Vrest,lists:reverse(NewVal)++Acc);
-		_ ->
-		    NewVal
-	    end;
-	_ ->
+    validate_oid(S, OidType, Vrest, [Value|Acc]);
+validate_oid(S, OidType, [#'Externalvaluereference'{}=Id|Vrest], Acc) ->
+    NeededOidType = case Acc of
+			[] -> o_id;
+			[_|_] -> rel_oid
+		    end,
+    try get_oid_value(S, NeededOidType, true, Id) of
+	Val when is_integer(Val) ->
+	    validate_oid(S, OidType, Vrest, [Val|Acc]);
+	Val when is_tuple(Val) ->
+	    L = tuple_to_list(Val),
+	    validate_oid(S, OidType, Vrest, lists:reverse(L, Acc))
+    catch
+	_:_ ->
 	    case reserved_objectid(Id#'Externalvaluereference'.value, Acc) of
 		Value when is_integer(Value) ->
-		    validate_oid(valid_objectid(OID,Value,Acc),
-				 S, OID,Vrest, [Value|Acc]);
+		    validate_oid(S, OidType,Vrest, [Value|Acc]);
 		false ->
-		    error({value, {"illegal "++to_string(OID),[Id,Vrest],Acc}, S})
+		    asn1_error(S, {illegal_oid,OidType})
 	    end
     end;
-validate_oid(_, S, OID, [{Atom,Value}],[]) 
-  when is_atom(Atom),is_integer(Value) ->
-    %% this case when an OBJECT IDENTIFIER value has been parsed as a 
-    %% SEQUENCE value
-    Rec = #'Externalvaluereference'{module=S#state.mname,
-				    value=Atom},
-    validate_objectidentifier1(S, OID, [Rec,Value]);
-validate_oid(_, S, OID, [{Atom,EVRef}],[]) 
-  when is_atom(Atom),is_record(EVRef,'Externalvaluereference') ->
-    %% this case when an OBJECT IDENTIFIER value has been parsed as a 
-    %% SEQUENCE value OTP-4354
-    Rec = #'Externalvaluereference'{module=EVRef#'Externalvaluereference'.module,
-				    value=Atom},
-    validate_objectidentifier1(S, OID, [Rec,EVRef]);
-validate_oid(_, S, OID, [Atom|Rest],Acc) when is_atom(Atom) ->
-    Rec = #'Externalvaluereference'{module=S#state.mname,
-				    value=Atom},
-    validate_oid(true,S, OID, [Rec|Rest],Acc);
-validate_oid(_, S, OID, V, Acc) ->
-    error({value, {"illegal "++to_string(OID),V,Acc},S}).
-
-is_object_id(OID,S,ERef=#'Externaltypereference'{}) ->
-    {_,OI} = get_referenced_type(S,ERef),
-    is_object_id(OID,S,OI#typedef.typespec);
-is_object_id(o_id,_S,'OBJECT IDENTIFIER') ->
-    true;
-is_object_id(rel_oid,_S,'RELATIVE-OID') ->
-    true;
-is_object_id(_,_S,'INTEGER') ->
-    true;
-is_object_id(OID,S,#type{def=Def}) ->
-    is_object_id(OID,S,Def);
-is_object_id(_,_S,_) ->
-    false.
-
-to_string(o_id) ->
-    "OBJECT IDENTIFIER";
-to_string(rel_oid) ->
-    "RELATIVE-OID".
+validate_oid(S, OidType, _V, _Acc) ->
+    asn1_error(S, {illegal_oid,OidType}).
+
+get_oid_type(S, OidType, #type{def=Def}) ->
+    get_oid_type(S, OidType, Def);
+get_oid_type(S, OidType, #'Externaltypereference'{}=Id) ->
+    {_,OI} = get_referenced_type(S, Id),
+    get_oid_type(S, OidType, OI#typedef.typespec);
+get_oid_type(_S, o_id, 'OBJECT IDENTIFIER'=T) ->
+    T;
+get_oid_type(_S, rel_oid, 'RELATIVE-OID'=T) ->
+    T;
+get_oid_type(_S, _, 'INTEGER'=T) ->
+    T;
+get_oid_type(S, OidType, _) ->
+    asn1_error(S, {illegal_oid,OidType}).
 
 %% ITU-T Rec. X.680 Annex B - D
 reserved_objectid('itu-t',[]) -> 0;
@@ -2357,7 +1906,6 @@ reserved_objectid('x',[0,0]) -> 24;
 reserved_objectid('y',[0,0]) -> 25;
 reserved_objectid('z',[0,0]) -> 26;
 
-
 reserved_objectid(iso,[]) -> 1;
 %% arcs below "iso", note that number 1 is not used
 reserved_objectid('standard',[1]) -> 0;
@@ -2369,31 +1917,28 @@ reserved_objectid('joint-iso-ccitt',[]) -> 2;
 
 reserved_objectid(_,_) -> false.
 
-valid_objectid(_OID,[],_Acc) ->
-    true;
-valid_objectid(OID,[H|T],Acc) ->
-    case valid_objectid(OID, H, Acc) of
-	true ->
-	    valid_objectid(OID,T,[H|Acc]);
-	_ ->
-	    false
-    end;
-valid_objectid(o_id,I,[]) when I =:= 0; I =:= 1; I =:= 2 -> true;
-valid_objectid(o_id,_I,[]) -> false;
-valid_objectid(o_id,I,[0]) when I >= 0; I =< 4 -> true;
-valid_objectid(o_id,_I,[0]) -> false;
-valid_objectid(o_id,I,[1]) when I =:= 0; I =:= 2; I =:= 3 -> true;
-valid_objectid(o_id,_I,[1]) -> false;
-valid_objectid(o_id,_I,[2]) -> true;
-valid_objectid(_,_,_) -> true.
-
-validate_sequence(S=#state{type=Vtype},Value,_Components,_Constr) ->
+validate_oid_path(_, rel_oid, _) ->
+    ok;
+validate_oid_path(_, o_id, [0,I|_]) when 0 =< I, I =< 9 ->
+    ok;
+validate_oid_path(_, o_id, [1,I|_]) when 0 =< I, I =< 3 ->
+    ok;
+validate_oid_path(_, o_id, [2|_]) ->
+    ok;
+validate_oid_path(S, o_id=OidType, _) ->
+    asn1_error(S, {illegal_oid,OidType}).
+
+%%%
+%%% End of OBJECT IDENTFIER/RELATIVE-OID validation.
+%%%
+
+convert_external(S, Vtype, Value) ->
     case Vtype of
 	#type{tag=[{tag,'UNIVERSAL',8,'IMPLICIT',32}]} ->
 	    %% this is an 'EXTERNAL' (or INSTANCE OF)
 	    case Value of
-		[{identification,_}|_RestVal] ->
-		    {ok,to_EXTERNAL1990(S,Value)};
+		[{#seqtag{val=identification},_}|_] ->
+		    {ok,to_EXTERNAL1990(S, Value)};
 		_ ->
 		    {ok,Value}
 	    end;
@@ -2401,22 +1946,26 @@ validate_sequence(S=#state{type=Vtype},Value,_Components,_Constr) ->
 	    {ok,Value}
     end.
 
-to_EXTERNAL1990(S,[{identification,{'CHOICE',{syntax,Stx}}}|Rest]) ->
-    to_EXTERNAL1990(S,Rest,[{'direct-reference',Stx}]);
-to_EXTERNAL1990(S,[{identification,{'CHOICE',{'presentation-context-id',I}}}|Rest]) ->
-    to_EXTERNAL1990(S,Rest,[{'indirect-reference',I}]);
-to_EXTERNAL1990(S,[{identification,{'CHOICE',{'context-negotiation',[{_,PCid},{_,TrStx}]}}}|Rest]) ->
-    to_EXTERNAL1990(S,Rest,[{'indirect-reference',PCid},{'direct-reference',TrStx}]);
-to_EXTERNAL1990(S,_) ->
-    error({value,"illegal value in EXTERNAL type",S}).
-
-to_EXTERNAL1990(S,[V={'data-value-descriptor',_}|Rest],Acc) ->
-    to_EXTERNAL1990(S,Rest,[V|Acc]);
-to_EXTERNAL1990(_S,[{'data-value',Val}],Acc) ->
-    Encoding = {encoding,{'CHOICE',{'octet-aligned',Val}}},
+to_EXTERNAL1990(S, [{#seqtag{val=identification}=T,
+		     {'CHOICE',{syntax,Stx}}}|Rest]) ->
+    to_EXTERNAL1990(S, Rest, [{T#seqtag{val='direct-reference'},Stx}]);
+to_EXTERNAL1990(S, [{#seqtag{val=identification}=T,
+		     {'CHOICE',{'presentation-context-id',I}}}|Rest]) ->
+    to_EXTERNAL1990(S, Rest, [{T#seqtag{val='indirect-reference'},I}]);
+to_EXTERNAL1990(S, [{#seqtag{val=identification}=T,
+		     {'CHOICE',{'context-negotiation',[{_,PCid},{_,TrStx}]}}}|Rest]) ->
+    to_EXTERNAL1990(S, Rest, [{T#seqtag{val='indirect-reference'},PCid},
+			      {T#seqtag{val='direct-reference'},TrStx}]);
+to_EXTERNAL1990(S, _) ->
+    asn1_error(S, illegal_external_value).
+
+to_EXTERNAL1990(S, [V={#seqtag{val='data-value-descriptor'},_}|Rest], Acc) ->
+    to_EXTERNAL1990(S, Rest, [V|Acc]);
+to_EXTERNAL1990(_S, [{#seqtag{val='data-value'}=T,Val}], Acc) ->
+    Encoding = {T#seqtag{val=encoding},{'CHOICE',{'octet-aligned',Val}}},
     lists:reverse([Encoding|Acc]);
-to_EXTERNAL1990(S,_,_) ->
-    error({value,"illegal value in EXTERNAL type",S}).
+to_EXTERNAL1990(S, _, _) ->
+    asn1_error(S, illegal_external_value).
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% Functions to normalize the default values of SEQUENCE 
@@ -2426,17 +1975,16 @@ normalize_value(_,_,mandatory,_) ->
     mandatory;
 normalize_value(_,_,'OPTIONAL',_) ->
     'OPTIONAL';
-normalize_value(S0, Type, {'DEFAULT',Value}, NameList) ->
-    S = S0#state{value=Value},
+normalize_value(S, Type, {'DEFAULT',Value}, NameList) ->
     case catch get_canonic_type(S,Type,NameList) of
 	{'BOOLEAN',CType,_} ->
 	    normalize_boolean(S,Value,CType);
 	{'INTEGER',CType,_} ->
-	    normalize_integer(S,Value,CType);
+	    normalize_integer(S, Value, CType);
 	{'BIT STRING',CType,_} ->
 	    normalize_bitstring(S,Value,CType);
-	{'OCTET STRING',CType,_} ->
-	    normalize_octetstring(S,Value,CType);
+	{'OCTET STRING',_,_} ->
+	    normalize_octetstring(S, Value);
 	{'NULL',_CType,_} ->
 	    %%normalize_null(Value);
 	    'NULL';
@@ -2472,123 +2020,100 @@ normalize_value(S0, Type, {'DEFAULT',Value}, NameList) ->
 normalize_value(S,Type,Val,NameList) ->
     normalize_value(S,Type,{'DEFAULT',Val},NameList).
 
-normalize_boolean(S,{Name,Bool},CType) when is_atom(Name) ->
-    normalize_boolean(S,Bool,CType);
 normalize_boolean(_,true,_) ->
     true;
 normalize_boolean(_,false,_) ->
     false;
 normalize_boolean(S,Bool=#'Externalvaluereference'{},CType) ->
     get_normalized_value(S,Bool,CType,fun normalize_boolean/3,[]);
-normalize_boolean(_,Other,_) ->
-    throw({error,{asn1,{'invalid default value',Other}}}).
+normalize_boolean(S, _, _) ->
+    asn1_error(S, {illegal_value, "BOOLEAN"}).
 
-normalize_integer(_S,Int,_) when is_integer(Int) ->
+normalize_integer(_S, Int, _) when is_integer(Int) ->
     Int;
-normalize_integer(_S,{Name,Int},_) when is_atom(Name),is_integer(Int) ->
-    Int;
-normalize_integer(S,{Name,Int=#'Externalvaluereference'{}},
-		  Type) when is_atom(Name) ->
-    normalize_integer(S,Int,Type);
-normalize_integer(S,Int=#'Externalvaluereference'{value=Name},Type) ->
-    case Type of
-	NNL when is_list(NNL) ->
-	    case lists:keysearch(Name,1,NNL) of
-		{value,{Name,Val}} ->
+normalize_integer(S, #'Externalvaluereference'{value=Name}=Ref, NNL) ->
+    case lists:keyfind(Name, 1, NNL) of
+	{Name,Val} ->
+	    Val;
+	false ->
+	    try get_referenced_value(S, Ref) of
+		Val when is_integer(Val) ->
 		    Val;
-		false ->
-		    get_normalized_value(S,Int,Type,
-					 fun normalize_integer/3,[])
-	    end;
+		_ ->
+		    asn1_error(S, illegal_integer_value)
+	    catch
+		throw:_ ->
+		    asn1_error(S, illegal_integer_value)
+	    end
+    end;
+normalize_integer(S, {'ValueFromObject',{object,Obj},FieldNames}, _) ->
+    case extract_field(S, Obj, FieldNames) of
+	#valuedef{value=Val} when is_integer(Val) ->
+	    Val;
 	_ ->
-	    get_normalized_value(S,Int,Type,fun normalize_integer/3,[])
+	    asn1_error(S, illegal_integer_value)
     end;
-normalize_integer(_,Int,_) ->
-    exit({'Unknown INTEGER value',Int}).
-
-normalize_bitstring(S,Value,Type)->
-    %% There are four different Erlang formats of BIT STRING:
-    %% 1 - a list of ones and zeros.
-    %% 2 - a list of atoms.
-    %% 3 - as an integer, for instance in hexadecimal form.
-    %% 4 - as a tuple {Unused, Binary} where Unused is an integer
-    %%   and tells how many bits of Binary are unused.
-    %% 
-    %% normalize_bitstring/3 transforms Value according to:
-    %% A to 3,
-    %% B to 1,
-    %% C to 1 or 3
-    %% D to 2,
-    %% Value can be on format:
-    %% A - {hstring, String}, where String is a hexadecimal string.
-    %% B - {bstring, String}, where String is a string on bit format
-    %% C - #'Externalvaluereference'{value=V}, where V is a defined value
-    %% D - list of #'Externalvaluereference', where each value component
-    %%     is an identifier corresponing to NamedBits in Type.
-    %% E - list of ones and zeros, if Value already is normalized.
+normalize_integer(S, _, _) ->
+    asn1_error(S, illegal_integer_value).
+
+%% normalize_bitstring(S, Value, Type) -> bitstring()
+%%  Convert a literal value for a BIT STRING to an Erlang bit string.
+%%
+normalize_bitstring(S, Value, Type)->
     case Value of
 	{hstring,String} when is_list(String) ->
-	    hstring_to_int(String);
+	    hstring_to_bitstring(String);
 	{bstring,String} when is_list(String) ->
-	    bstring_to_bitlist(String);
-	Rec when is_record(Rec,'Externalvaluereference') ->
-	    get_normalized_value(S,Value,Type,
-				 fun normalize_bitstring/3,[]);
-	RecList when is_list(RecList) ->
-	    case Type of
-		NBL when is_list(NBL) ->
-		    F = fun(#'Externalvaluereference'{value=Name}) ->
-				case lists:keysearch(Name,1,NBL) of
-				    {value,{Name,_}} ->
-					Name;
-				    Other ->
-					throw({error,Other})
-				end;
-			   (I) when I =:= 1; I =:= 0 ->
-				I;
-			   (Other) ->
-				throw({error,Other})
-			end,
-		    case catch lists:map(F,RecList) of
-			{error,Reason} ->
-			    asn1ct:warning("default value not "
-					   "compatible with type definition ~p~n",
-					   [Reason],S,
-					   "default value not "
-					   "compatible with type definition"),
-			    Value;
-			NewList ->
-			    NewList
-		    end;
+	    bstring_to_bitstring(String);
+	#'Externalvaluereference'{} ->
+	    Val = get_referenced_value(S, Value),
+	    normalize_bitstring(S, Val, Type);
+	{'ValueFromObject',{object,Obj},FieldNames} ->
+	    case extract_field(S, Obj, FieldNames) of
+		#valuedef{value=Val} ->
+		    normalize_bitstring(S, Val, Type);
 		_ ->
-		    asn1ct:warning("default value not "
-				   "compatible with type definition ~p~n",
-				   [RecList],S,
-				   "default value not "
-				   "compatible with type definition"),
-		    Value
+		    asn1_error(S, {illegal_value, "BIT STRING"})
 	    end;
-	{Name,String} when is_atom(Name) ->
-	    normalize_bitstring(S,String,Type);
-	Other ->
-	    asn1ct:warning("illegal default value ~p~n",[Other],S,
-			   "illegal default value"),
-	    Value
+	RecList when is_list(RecList) ->
+	    [normalize_bs_item(S, Item, Type) || Item <- RecList];
+	Bs when is_bitstring(Bs) ->
+	    %% Already normalized.
+	    Bs;
+	_ ->
+	    asn1_error(S, {illegal_value, "BIT STRING"})
     end.
 
-hstring_to_int(L) when is_list(L) ->
-    hstring_to_int(L,0).
-hstring_to_int([H|T],Acc) when H >= $A, H =< $F ->
-    hstring_to_int(T,(Acc bsl 4) + (H - $A + 10) ) ;
-hstring_to_int([H|T],Acc) when H >= $0, H =< $9 ->
-    hstring_to_int(T,(Acc bsl 4) + (H - $0));
-hstring_to_int([],Acc) ->
-    Acc.
+normalize_bs_item(S, #'Externalvaluereference'{value=Name}, Type) ->
+    case lists:keymember(Name, 1, Type) of
+	true -> Name;
+	false -> asn1_error(S, {illegal_value, "BIT STRING"})
+    end;
+normalize_bs_item(_, Atom, _) when is_atom(Atom) ->
+    Atom;
+normalize_bs_item(S, _, _) ->
+    asn1_error(S, {illegal_value, "BIT STRING"}).
 
-bstring_to_bitlist([H|T]) when H == $0; H == $1 ->
-    [H - $0 | bstring_to_bitlist(T)];
-bstring_to_bitlist([]) ->
-    [].
+hstring_to_binary(L) ->
+    byte_align(hstring_to_bitstring(L)).
+
+bstring_to_binary(L) ->
+    byte_align(bstring_to_bitstring(L)).
+
+byte_align(Bs) ->
+    case bit_size(Bs) rem 8 of
+	0 -> Bs;
+	N -> <<Bs/bitstring,0:(8-N)>>
+    end.
+
+hstring_to_bitstring(L) ->
+    << <<(hex_to_int(D)):4>> || D <- L >>.
+
+bstring_to_bitstring(L) ->
+    << <<(D-$0):1>> || D <- L >>.
+
+hex_to_int(D) when $0 =< D, D =< $9 -> D - $0;
+hex_to_int(D) when $A =< D, D =< $F -> D - ($A - 10).
 
 %% normalize_octetstring/1 changes representation of input Value to a 
 %% list of octets.
@@ -2596,69 +2121,35 @@ bstring_to_bitlist([]) ->
 %% {bstring,String} each element in String corresponds to one bit in an octet
 %% {hstring,String} each element in String corresponds to one byte in an octet
 %% #'Externalvaluereference'
-normalize_octetstring(S,Value,CType) ->
+normalize_octetstring(S, Value) ->
     case Value of
 	{bstring,String} ->
-	    bstring_to_octetlist(String);
+	    bstring_to_binary(String);
 	{hstring,String} ->
-	    hstring_to_octetlist(String);
-	Rec when is_record(Rec,'Externalvaluereference') ->
-	    get_normalized_value(S,Value,CType,
-				 fun normalize_octetstring/3,[]);
-	{Name,String} when is_atom(Name) ->
-	    normalize_octetstring(S,String,CType);
-	List when is_list(List) ->
-	    %% check if list elements are valid octet values
-	    lists:map(fun([])-> ok;
-			 (H)when H > 255->
-			      asn1ct:warning("not legal octet value ~p in OCTET STRING, ~p~n",
-					     [H,List],S,
-					     "not legal octet value ~p in OCTET STRING");
-			 (_)-> ok
-		      end, List),
-	    List;
-	Other ->
-	    asn1ct:warning("unknown default value ~p~n",[Other],S,
-			   "unknown default value"),
-	    Value
+	    hstring_to_binary(String);
+	#'Externalvaluereference'{} ->
+	    case get_referenced_value(S, Value) of
+		String when is_binary(String) ->
+		    String;
+		Other ->
+		    normalize_octetstring(S, Other)
+	    end;
+	{'ValueFromObject',{object,Obj},FieldNames} ->
+	    case extract_field(S, Obj, FieldNames) of
+		#valuedef{value=Val} when is_binary(Val) ->
+		    Val;
+		_ ->
+		    asn1_error(S, illegal_octet_string_value)
+	    end;
+	_ ->
+	    asn1_error(S, illegal_octet_string_value)
     end.
 
-
-bstring_to_octetlist([]) ->
-    [];
-bstring_to_octetlist([H|T]) when H == $0 ; H == $1 ->
-    bstring_to_octetlist(T,6,[(H - $0) bsl 7]).
-bstring_to_octetlist([H|T],0,[Hacc|Tacc]) when H == $0; H == $1 ->
-    bstring_to_octetlist(T, 7, [0,Hacc + (H -$0)| Tacc]);
-bstring_to_octetlist([H|T],BSL,[Hacc|Tacc]) when H == $0; H == $1 ->
-    bstring_to_octetlist(T, BSL-1, [Hacc + ((H - $0) bsl BSL)| Tacc]);
-bstring_to_octetlist([],7,[0|Acc]) ->
-    lists:reverse(Acc);
-bstring_to_octetlist([],_,Acc) ->
-    lists:reverse(Acc).
-
-hstring_to_octetlist([]) ->
-    [];
-hstring_to_octetlist(L) ->
-    hstring_to_octetlist(L,4,[]).
-hstring_to_octetlist([H|T],0,[Hacc|Tacc]) when H >= $A, H =< $F ->
-    hstring_to_octetlist(T,4,[Hacc + (H - $A + 10)|Tacc]);
-hstring_to_octetlist([H|T],BSL,Acc) when H >= $A, H =< $F ->
-    hstring_to_octetlist(T,0,[(H - $A + 10) bsl BSL|Acc]);
-hstring_to_octetlist([H|T],0,[Hacc|Tacc]) when H >= $0; H =< $9 ->
-    hstring_to_octetlist(T,4,[Hacc + (H - $0)|Tacc]);
-hstring_to_octetlist([H|T],BSL,Acc) when H >= $0; H =< $9 ->
-    hstring_to_octetlist(T,0,[(H - $0) bsl BSL|Acc]);
-hstring_to_octetlist([],_,Acc) ->
-    lists:reverse(Acc).
-
 normalize_objectidentifier(S, Value) ->
-    {ok,Val} = validate_objectidentifier(S, o_id, Value, []),
-    Val.
+    validate_objectidentifier(S, o_id, Value).
 
-normalize_relative_oid(S,Value) ->
-    {ok,Val} = validate_objectidentifier(S, rel_oid, Value, []),
-    Val.
+normalize_relative_oid(S, Value) ->
+    validate_objectidentifier(S, rel_oid, Value).
 
 normalize_objectdescriptor(Value) ->
     Value.
@@ -2666,51 +2157,36 @@ normalize_objectdescriptor(Value) ->
 normalize_real(Value) ->
     Value.
 
-normalize_enumerated(S, Id, {Base,Ext}) ->
+normalize_enumerated(S, Id0, NNL) ->
+    {Id,_} = lookup_enum_value(S, Id0, NNL),
+    Id.
+
+lookup_enum_value(S, Id, {Base,Ext}) ->
     %% Extensible ENUMERATED.
-    normalize_enumerated(S, Id, Base++Ext);
-normalize_enumerated(S, #'Externalvaluereference'{value=Id},
-		    NamedNumberList) ->
-    normalize_enumerated(S, Id, NamedNumberList);
-normalize_enumerated(S, Id, NamedNumberList) when is_atom(Id) ->
-    case lists:keymember(Id, 1, NamedNumberList) of
-	true ->
-	    Id;
+    lookup_enum_value(S, Id, Base++Ext);
+lookup_enum_value(S, #'Externalvaluereference'{value=Id}, NNL) ->
+    lookup_enum_value(S, Id, NNL);
+lookup_enum_value(S, Id, NNL) when is_atom(Id) ->
+    case lists:keyfind(Id, 1, NNL) of
+	{_,_}=Ret ->
+	    Ret;
 	false ->
-	    throw(asn1_error(S, S#state.value, {undefined,Id}))
+	    asn1_error(S, {undefined,Id})
     end.
 
-normalize_choice(S,{'CHOICE',{C,V}},CType,NameList) when is_atom(C) ->
-    case catch lists:keysearch(C,#'ComponentType'.name,CType) of
-	{value,#'ComponentType'{typespec=CT,name=Name}} ->
-	    {C,normalize_value(S,CT,{'DEFAULT',V},
-			       [Name|NameList])};
-	Other ->
-	    asn1ct:warning("Wrong format of type/value ~p/~p~n",[Other,V],S,
-			   "Wrong format of type/value"),
-	    {C,V}
+normalize_choice(S, {'CHOICE',{C,V}}, CType, NameList)
+  when is_atom(C) ->
+    case lists:keyfind(C, #'ComponentType'.name, CType) of
+	#'ComponentType'{typespec=CT,name=Name} ->
+	    {C,normalize_value(S, CT, {'DEFAULT',V}, [Name|NameList])};
+	false ->
+	    asn1_error(S, {illegal_id,C})
     end;
-normalize_choice(S,{'DEFAULT',ValueList},CType,NameList) when is_list(ValueList) ->
-    lists:map(fun(X)-> normalize_choice(S,X,CType,NameList) end, ValueList);
-normalize_choice(S,Val=#'Externalvaluereference'{},CType,NameList) ->
-    {M,#valuedef{value=V}}=get_referenced_type(S,Val),
-    normalize_choice(update_state(S,M),{'CHOICE',V},CType,NameList);
-%    get_normalized_value(S,Val,CType,fun normalize_choice/4,[NameList]);
-normalize_choice(S,CV={Name,_ChoiceVal},CType,NameList) 
+normalize_choice(S,CV={Name,_ChoiceVal},CType,NameList)
   when is_atom(Name) ->
-%    normalize_choice(S,ChoiceVal,CType,NameList).
     normalize_choice(S,{'CHOICE',CV},CType,NameList);
-normalize_choice(_S,V,_CType,_NameList) ->
-    exit({error,{bad_choice_value,V}}).
-
-%% normalize_choice(NameList,S,CVal = {'CHOICE',{_,_}},CType,_) ->
-%%     normalize_choice(S,CVal,CType,NameList);
-%% normalize_choice(NameList,S,CVal={'DEFAULT',VL},CType,_) when is_list(VL)->
-%%     normalize_choice(S,CVal,CType,NameList);
-%% normalize_choice(NameList,S,CV={Name,_CV},CType,_) when is_atom(Name)->
-%%     normalize_choice(S,{'CHOICE',CV},CType,NameList);
-%% normalize_choice(_,_S,V,_,_) ->
-%%     V.
+normalize_choice(S, V, _CType, _NameList) ->
+    asn1_error(S, {illegal_id, error_value(V)}).
 
 normalize_sequence(S,Value,Components,NameList) 
   when is_tuple(Components) ->
@@ -2737,20 +2213,20 @@ normalize_set(S,Value,Components,NameList) ->
 	    normalized_record('SET',S,SortedVal,Components,NameList)
     end.
 
-sort_value(Components,Value) ->
-    ComponentNames = lists:map(fun(#'ComponentType'{name=Cname}) -> Cname end,
-			       Components),
-    sort_value1(ComponentNames,Value,[]).
-sort_value1(_,V=#'Externalvaluereference'{},_) ->
-    %% sort later, get the value in normalize_seq_or_set
-    V;
-sort_value1([N|Ns],Value,Acc) ->
-    case lists:keysearch(N,1,Value) of
-	{value,V} ->sort_value1(Ns,Value,[V|Acc]);
-	_ -> sort_value1(Ns,Value,Acc)
-    end;
-sort_value1([],_,Acc) ->
-    lists:reverse(Acc).
+sort_value(Components, Value0) when is_list(Value0) ->
+    {Keys0,_} = lists:mapfoldl(fun(#'ComponentType'{name=N}, I) ->
+				       {{N,I},I+1}
+			       end, 0, Components),
+    Keys = gb_trees:from_orddict(orddict:from_list(Keys0)),
+    Value1 = [{case gb_trees:lookup(N, Keys) of
+		   {value,K} -> K;
+		   none -> 'end'
+	       end,Pair} || {#seqtag{val=N},_}=Pair <- Value0],
+    Value = lists:sort(Value1),
+    [Pair || {_,Pair} <- Value];
+sort_value(_Components, #'Externalvaluereference'{}=Value) ->
+    %% Sort later.
+    Value.
 
 sort_val_if_set(['SET'|_],Val,Type) ->
     sort_value(Type,Val);
@@ -2765,12 +2241,9 @@ normalized_record(SorS,S,Value,Components,NameList) ->
 	    Value;
 	_ ->
 	    NoComps = length(Components),
-	    case normalize_seq_or_set(SorS,S,Value,Components,NameList,[]) of
-		ListOfVals when length(ListOfVals) == NoComps ->
-		    list_to_tuple([NewName|ListOfVals]);
-		_ ->
-		    error({type,{illegal,default,value,Value},S})
-	    end
+	    ListOfVals = normalize_seq_or_set(SorS,S,Value,Components,NameList,[]),
+	    NoComps = length(ListOfVals), %% Assert
+	    list_to_tuple([NewName|ListOfVals])
     end.
 is_record_normalized(S,Name,V = #'Externalvaluereference'{},NumComps) ->
     case get_referenced_type(S,V) of
@@ -2783,10 +2256,11 @@ is_record_normalized(_S,Name,Value,NumComps) when is_tuple(Value) ->
 is_record_normalized(_,_,_,_) ->
     false.
 
-normalize_seq_or_set(SorS,S,[{Cname,V}|Vs],
+normalize_seq_or_set(SorS, S,
+		     [{#seqtag{val=Cname},V}|Vs],
 		     [#'ComponentType'{name=Cname,typespec=TS}|Cs],
-		     NameList,Acc) ->
-    NewNameList = 
+		     NameList, Acc) ->
+    NewNameList =
 	case TS#type.def of
 	    #'Externaltypereference'{type=TName} ->
 		[TName];
@@ -2794,24 +2268,26 @@ normalize_seq_or_set(SorS,S,[{Cname,V}|Vs],
 	end,
     NVal = normalize_value(S,TS,{'DEFAULT',V},NewNameList),
     normalize_seq_or_set(SorS,S,Vs,Cs,NameList,[NVal|Acc]);
-normalize_seq_or_set(SorS,S,Values=[{_Cname1,_V}|_Vs],
+normalize_seq_or_set(SorS, S,
+		     Values=[{#seqtag{val=Cname0},_V}|_Vs],
 		     [#'ComponentType'{prop='OPTIONAL'}|Cs],
-		     NameList,Acc) ->
+		     NameList, Acc) ->
+    verify_valid_component(S, Cname0, Cs),
     normalize_seq_or_set(SorS,S,Values,Cs,NameList,[asn1_NOVALUE|Acc]);
-normalize_seq_or_set(SorS,S,Values=[{_Cname1,_V}|_Vs],
-		    [#'ComponentType'{name=Cname2,typespec=TS,
-				      prop={'DEFAULT',Value}}|Cs],
-		    NameList,Acc) ->
-    NewNameList = 
+normalize_seq_or_set(SorS, S,
+		     Values=[{#seqtag{val=Cname0},_V}|_Vs],
+		     [#'ComponentType'{name=Cname,typespec=TS,
+				       prop={'DEFAULT',Value}}|Cs],
+		    NameList, Acc) ->
+    verify_valid_component(S, Cname0, Cs),
+    NewNameList =
 	case TS#type.def of
 	    #'Externaltypereference'{type=TName} ->
 		[TName];
-	    _ -> [Cname2|NameList]
+	    _ -> [Cname|NameList]
 	end,
     NVal =  normalize_value(S,TS,{'DEFAULT',Value},NewNameList),
     normalize_seq_or_set(SorS,S,Values,Cs,NameList,[NVal|Acc]);
-normalize_seq_or_set(_SorS,_S,[],[],_,Acc) ->
-    lists:reverse(Acc);
 %% If default value is {} ComponentTypes in SEQUENCE are marked DEFAULT 
 %% or OPTIONAL (or the type is defined SEQUENCE{}, which is handled by
 %% the previous case).
@@ -2834,9 +2310,23 @@ normalize_seq_or_set(SorS,S,Value=#'Externalvaluereference'{},
 		     Cs,NameList,Acc) ->
     get_normalized_value(S,Value,Cs,fun normalize_seq_or_set/6,
 			 [SorS,NameList,Acc]);
-normalize_seq_or_set(_SorS,S,V,_,_,_) ->
-    error({type,{illegal,default,value,V},S}).
-	
+normalize_seq_or_set(_SorS, _S, [], [], _, Acc) ->
+    lists:reverse(Acc);
+normalize_seq_or_set(_SorS, S, V, Cs, _, _) ->
+    case V of
+	[{#seqtag{val=Name},_}|_] ->
+	    asn1_error(S, {illegal_id,error_value(Name)});
+	[] ->
+	    [#'ComponentType'{name=Name}|_] = Cs,
+	    asn1_error(S, {missing_id,error_value(Name)})
+    end.
+
+verify_valid_component(S, Name, Cs) ->
+    case lists:keyfind(Name, #'ComponentType'.name, Cs) of
+	false -> asn1_error(S, {illegal_id,error_value(Name)});
+	#'ComponentType'{} -> ok
+    end.
+
 normalize_seqof(S,Value,Type,NameList) ->
     normalize_s_of('SEQUENCE OF',S,Value,Type,NameList).
 
@@ -2892,10 +2382,7 @@ normalize_restrictedstring(_S,CString,_) when is_list(CString) ->
 %% definedvalue case or argument in a parameterized type
 normalize_restrictedstring(S,ERef,CType) when is_record(ERef,'Externalvaluereference') ->
     get_normalized_value(S,ERef,CType,
-			 fun normalize_restrictedstring/3,[]);
-%% 
-normalize_restrictedstring(S,{Name,Val},CType) when is_atom(Name) ->
-    normalize_restrictedstring(S,Val,CType).
+			 fun normalize_restrictedstring/3,[]).
 
 normalize_objectclassfieldvalue(S,{opentypefieldvalue,Type,Value},NameList) ->
     %% An open type has per definition no type. Thus should the type
@@ -2943,6 +2430,8 @@ call_Func(S,Val,Type,Func,ArgList) ->
 get_canonic_type(S,Type,NameList) ->
     {InnerType,NewType,NewNameList} =
 	case Type#type.def of
+	    'INTEGER'=Name ->
+		{Name,[],NameList};
 	    Name when is_atom(Name) ->
 		{Name,Type,NameList};
 	    Ref when is_record(Ref,'Externaltypereference') ->
@@ -2963,8 +2452,7 @@ get_canonic_type(S,Type,NameList) ->
 
 
 check_ptype(S,Type,Ts) when is_record(Ts,type) ->
-    %Tag = Ts#type.tag,
-    %Constr = Ts#type.constraint,
+    check_formal_parameters(S, Type#ptypedef.args),
     Def = Ts#type.def,
     NewDef= 
 	case Def of 
@@ -2990,6 +2478,16 @@ check_ptype(S,Type,Ts) when is_record(Ts,type) ->
 check_ptype(_S,_PTDef,Ts) when is_record(Ts,objectclass) ->
     throw({asn1_param_class,Ts}).
 
+check_formal_parameters(S, Args) ->
+    _ = [check_formal_parameter(S, A) || A <- Args],
+    ok.
+
+check_formal_parameter(_, {_,_}) ->
+    ok;
+check_formal_parameter(_, #'Externaltypereference'{}) ->
+    ok;
+check_formal_parameter(S, #'Externalvaluereference'{value=Name}) ->
+    asn1_error(S, {illegal_typereference,Name}).
 
 % check_type(S,Type,ObjSpec={{objectclassname,_},_}) ->
  %     check_class(S,ObjSpec);
@@ -3001,7 +2499,7 @@ check_type(_S,Type,Ts) when is_record(Type,typedef),
     Ts;
 check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
     {Def,Tag,Constr,IsInlined} = 
-	case match_parameters(S,Ts#type.def,S#state.parameters) of
+	case match_parameter(S, Ts#type.def) of
 	    #type{tag=PTag,constraint=_Ctmp,def=Dtmp,inlined=Inl} ->
 		{Dtmp,merge_tags(Ts#type.tag,PTag),Ts#type.constraint,Inl};
 	    #typedef{typespec=#type{tag=PTag,def=Dtmp,inlined=Inl}} ->
@@ -3013,16 +2511,16 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 		       inlined=IsInlined},
     TestFun = 
 	fun(Tref) ->
-		MaybeChoice = get_non_typedef(S, Tref),
+		{_, MaybeChoice} = get_referenced_type(S, Tref, true),
 		case catch((MaybeChoice#typedef.typespec)#type.def) of
 		    {'CHOICE',_} ->
-			maybe_illicit_implicit_tag(choice,Tag);
+			maybe_illicit_implicit_tag(S, choice, Tag);
 		    'ANY' ->
-			maybe_illicit_implicit_tag(open_type,Tag);
+			maybe_illicit_implicit_tag(S, open_type, Tag);
 		    'ANY DEFINED BY' ->
-			maybe_illicit_implicit_tag(open_type,Tag);
+			maybe_illicit_implicit_tag(S, open_type, Tag);
 		    'ASN1_OPEN_TYPE' ->
-			maybe_illicit_implicit_tag(open_type,Tag);
+			maybe_illicit_implicit_tag(S, open_type, Tag);
 		    _ ->
 			Tag
 		end
@@ -3031,15 +2529,15 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 	case Def of 
 	    Ext when is_record(Ext,'Externaltypereference') ->
 		{RefMod,RefTypeDef,IsParamDef} = 
-		    case get_referenced_type(S,Ext) of
+		    case get_referenced_type(S, Ext) of
 			{undefined,TmpTDef} -> %% A parameter
 			    {get(top_module),TmpTDef,true};
 			{TmpRefMod,TmpRefDef} ->
 			    {TmpRefMod,TmpRefDef,false}
 		    end,
-		case is_class(S,RefTypeDef) of
-		    true -> throw({asn1_class,RefTypeDef});
-		    _ -> ok
+		case get_class_def(S, RefTypeDef) of
+		    none -> ok;
+		    #classdef{} -> throw({asn1_class,RefTypeDef})
 		end,
 		Ct = TestFun(Ext),
 		{RefType,ExtRef} = 
@@ -3055,7 +2553,6 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 			    NewS = S#state{mname=RefMod,
 					   module=load_asn1_module(S,RefMod),
 					   tname=get_datastr_name(NewRefTypeDef1),
-					   type=NewRefTypeDef1,
 					   abscomppath=[],recordtopname=[]},
 			    RefType1 = 
 				check_type(NewS,RefTypeDef,RefTypeDef#typedef.typespec),
@@ -3075,18 +2572,17 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 							   Key);
 				_ -> ok
 			    end,
+			    Pos = Ext#'Externaltypereference'.pos,
 			    {RefType1,#'Externaltypereference'{module=RefMod,
+							       pos=Pos,
 							       type=TmpName}}
 		    end,
 
 		case asn1ct_gen:prim_bif(asn1ct_gen:get_inner(RefType#type.def)) of
 		    true ->
 			%% Here we expand to a built in type and inline it
-			NewS2 = S#state{type=#typedef{typespec=RefType}},
-			NewC = 
-			    constraint_merge(NewS2,
-					     check_constraints(NewS2,Constr)++
-					     RefType#type.constraint),
+			NewC = check_constraints(S, RefType, Constr ++
+						     RefType#type.constraint),
 			TempNewDef#newt{
 			  type = RefType#type.def, 
 			  tag = merge_tags(Ct,RefType#type.tag),
@@ -3097,27 +2593,20 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 			NewExt = ExtRef#'Externaltypereference'{module=merged_mod(S,RefMod,Ext)},
 			TempNewDef#newt{
 			  type = check_externaltypereference(S,NewExt),
-			  tag = case S#state.erule of
-				    ber ->
-					merge_tags(Ct,RefType#type.tag);
-				    _ ->
-					Ct
-				end
-			 }
+			  tag = merge_tags(Ct,RefType#type.tag)}
 		end;
 	    'ANY' ->
-		Ct=maybe_illicit_implicit_tag(open_type,Tag),
+		Ct = maybe_illicit_implicit_tag(S, open_type, Tag),
 		TempNewDef#newt{type='ASN1_OPEN_TYPE',tag=Ct};
 	    {'ANY_DEFINED_BY',_} ->
-		Ct=maybe_illicit_implicit_tag(open_type,Tag),
+		Ct = maybe_illicit_implicit_tag(S, open_type, Tag),
 		TempNewDef#newt{type='ASN1_OPEN_TYPE',tag=Ct};
 	    'INTEGER' ->
-		check_integer(S,[],Constr),
 		TempNewDef#newt{tag=
 				merge_tags(Tag,?TAG_PRIMITIVE(?N_INTEGER))};
 
 	    {'INTEGER',NamedNumberList} ->
-		TempNewDef#newt{type={'INTEGER',check_integer(S,NamedNumberList,Constr)},
+		TempNewDef#newt{type={'INTEGER',check_integer(S,NamedNumberList)},
 				tag=
 				merge_tags(Tag,?TAG_PRIMITIVE(?N_INTEGER))};
 	    'REAL' ->
@@ -3125,8 +2614,7 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 
 		TempNewDef#newt{tag=merge_tags(Tag,?TAG_PRIMITIVE(?N_REAL))};
 	    {'BIT STRING',NamedNumberList} ->
-		NewL = check_bitstring(S,NamedNumberList,Constr),
-%%		erlang:display({asn1ct_check,NamedNumberList,NewL}),
+		NewL = check_bitstring(S, NamedNumberList),
 		TempNewDef#newt{type={'BIT STRING',NewL},
 				tag=
 				merge_tags(Tag,?TAG_PRIMITIVE(?N_BIT_STRING))};
@@ -3158,7 +2646,7 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 	    {'ENUMERATED',NamedNumberList} ->
 		TempNewDef#newt{type=
 				{'ENUMERATED',
-				 check_enumerated(S,NamedNumberList,Constr)},
+				 check_enumerated(S, NamedNumberList)},
 				tag=
 				merge_tags(Tag,?TAG_PRIMITIVE(?N_ENUMERATED)),
 				constraint=[]};
@@ -3261,7 +2749,7 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 				tag=
 				merge_tags(Tag,?TAG_CONSTRUCTED(?N_SEQUENCE))};
 	    {'CHOICE',Components} ->
-		Ct = maybe_illicit_implicit_tag(choice,Tag),
+		Ct = maybe_illicit_implicit_tag(S, choice, Tag),
 		TempNewDef#newt{type={'CHOICE',check_choice(S,Type,Components)},tag=Ct};
 	    Set when is_record(Set,'SET') ->
 		RecordName=
@@ -3284,12 +2772,6 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 		TempNewDef#newt{type={'SET OF',check_setof(S,Type,Components)},
 				tag=
 				merge_tags(Tag,?TAG_CONSTRUCTED(?N_SET))};
-	    %% This is a temporary hack until the full Information Obj Spec
-	    %% in X.681 is supported
-	    {#'Externaltypereference'{type='TYPE-IDENTIFIER'},
-	     [{typefieldreference,_,'Type'}]} ->
-		Ct=maybe_illicit_implicit_tag(open_type,Tag),
-		TempNewDef#newt{type='ASN1_OPEN_TYPE',tag=Ct};
 
 	    {pt,Ptype,ParaList} ->
 		%% Ptype might be a parameterized - type, object set or
@@ -3297,18 +2779,18 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 		%% calling function.
 		{_RefMod,Ptypedef} = get_referenced_type(S,Ptype),
 		notify_if_not_ptype(S,Ptypedef),
-		NewParaList = 
-		    [match_parameters(S,TmpParam,S#state.parameters)|| 
-				  TmpParam <- ParaList],
+		NewParaList = match_parameters(S, ParaList),
 		Instance = instantiate_ptype(S,Ptypedef,NewParaList),
 		TempNewDef#newt{type=Instance#type.def,
 				tag=merge_tags(Tag,Instance#type.tag),
 				constraint=Instance#type.constraint,
 				inlined=yes};
 
-	    OCFT=#'ObjectClassFieldType'{classname=ClRef} ->
+	    #'ObjectClassFieldType'{classname=ClRef0}=OCFT0 ->
 		%% this case occures in a SEQUENCE when 
 		%% the type of the component is a ObjectClassFieldType
+		ClRef = match_parameter(S, ClRef0),
+		OCFT = OCFT0#'ObjectClassFieldType'{classname=ClRef},
 		ClassSpec = check_class(S,ClRef),
 		NewTypeDef = 
 		    maybe_open_type(S,ClassSpec,
@@ -3318,16 +2800,18 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 		Ct =
 		    case is_open_type(NewTypeDef) of
 			true ->
-			    maybe_illicit_implicit_tag(open_type,MergedTag);
+			    maybe_illicit_implicit_tag(S, open_type, MergedTag);
 			_ ->
 			    MergedTag
 		    end,
 		case TopName of
 		    [] when Type#typedef.name =/= undefined ->
 			%% This is a top-level type.
-			#type{def=Simplified} =
-			    simplify_type(#type{def=NewTypeDef}),
-			TempNewDef#newt{type=Simplified,tag=Ct};
+			#type{constraint=C,def=Simplified} =
+			    simplify_type(#type{def=NewTypeDef,
+						constraint=Constr}),
+			TempNewDef#newt{type=Simplified,tag=Ct,
+					constraint=C};
 		    _ ->
 			TempNewDef#newt{type=NewTypeDef,tag=Ct}
 		end;
@@ -3337,33 +2821,21 @@ check_type(S=#state{recordtopname=TopName},Type,Ts) when is_record(Ts,type) ->
 		TempNewDef#newt{tag=merge_tags(Tag,CheckedT#type.tag),
 				type=CheckedT#type.def};
 
-	    {valueset,Vtype} ->
-		TempNewDef#newt{type={valueset,check_type(S,Type,Vtype)}};
 	    {'SelectionType',Name,T} ->
 		CheckedT = check_selectiontype(S,Name,T),
 		TempNewDef#newt{tag=merge_tags(Tag,CheckedT#type.tag),
 				type=CheckedT#type.def};
-	    Other ->
-		exit({'cant check' ,Other})
+	    'ASN1_OPEN_TYPE' ->
+		TempNewDef
 	end,
     #newt{type=TDef,tag=NewTags,constraint=NewConstr,inlined=Inlined} = NewDef,
     Ts#type{def=TDef,
 	    inlined=Inlined,
-	    constraint=check_constraints(S, NewConstr),
+	    constraint=check_constraints(S, #type{def=TDef}, NewConstr),
 	    tag=lists:map(fun(#tag{type={default,TTx}}=TempTag) ->
 				  TempTag#tag{type=TTx};
 			     (Other) -> Other
-			  end, NewTags)};
-check_type(_S,Type,Ts) ->
-    exit({error,{asn1,internal_error,Type,Ts}}).
-
-get_non_typedef(S, Tref0) ->
-    case get_referenced_type(S, Tref0) of
-	{_,#typedef{typespec=#type{def=#'Externaltypereference'{}=Tref}}} ->
-	    get_non_typedef(S, Tref);
-	{_,Type} ->
-	    Type
-    end.
+			  end, NewTags)}.
 
 
 %%
@@ -3379,10 +2851,11 @@ simplify_comp(#'ComponentType'{typespec=Type0}=C) ->
     C#'ComponentType'{typespec=Type};
 simplify_comp(Other) -> Other.
 
-simplify_type(#type{tag=Tag,def=Inner}=T) ->
+simplify_type(#type{tag=Tag,def=Inner,constraint=Constr0}=T) ->
     case Inner of
-	#'ObjectClassFieldType'{type={fixedtypevaluefield,_,Type}} ->
-	    Type#type{tag=Tag};
+	#'ObjectClassFieldType'{type={fixedtypevaluefield,_,Type}}=OCFT ->
+	    Constr = [{ocft,OCFT}|Type#type.constraint++Constr0],
+	    Type#type{tag=Tag,constraint=Constr};
 	_ ->
 	    T
     end.
@@ -3415,35 +2888,22 @@ get_innertag(_S,#'ObjectClassFieldType'{type=Type}) ->
 	_ -> []
     end.
     
-get_type_from_object(S,Object,TypeField)
-  when is_record(Object,'Externaltypereference');
-       is_record(Object,'Externalvaluereference') ->
-    {_,ObjectDef} = get_referenced_type(S,Object),
-    ObjSpec = check_object(S,ObjectDef,ObjectDef#typedef.typespec),
-    get_fieldname_element(S,ObjectDef#typedef{typespec=ObjSpec},TypeField).
-    
-is_class(_S,#classdef{}) ->
-    true;
-is_class(S,#typedef{typespec=#type{def=Eref}}) 
-  when is_record(Eref,'Externaltypereference')->
-    is_class(S,Eref);
-is_class(S,Eref) when is_record(Eref,'Externaltypereference')->
-    {_,NextDef} = get_referenced_type(S,Eref),
-    is_class(S,NextDef);
-is_class(_,_) ->
-    false.
-
-get_class_def(_S,CD=#classdef{}) ->
+%% get_class_def(S, Type) -> #classdef{} | 'none'.
+get_class_def(S, #typedef{typespec=#type{def=#'Externaltypereference'{}=Eref}}) ->
+    {_,NextDef} = get_referenced_type(S, Eref, true),
+    get_class_def(S, NextDef);
+get_class_def(S, #'Externaltypereference'{}=Eref) ->
+    {_,NextDef} = get_referenced_type(S, Eref, true),
+    get_class_def(S, NextDef);
+get_class_def(_S, #classdef{}=CD) ->
     CD;
-get_class_def(S,#typedef{typespec=#type{def=Eref}})
-  when is_record(Eref,'Externaltypereference') ->
-    {_,NextDef} = get_referenced_type(S,Eref),
-    get_class_def(S,NextDef).
+get_class_def(_S, _) ->
+    none.
     
-maybe_illicit_implicit_tag(Kind,Tag) ->
+maybe_illicit_implicit_tag(S, Kind, Tag) ->
     case Tag of
 	[#tag{type='IMPLICIT'}|_T] ->
-	    throw({error,{asn1,{implicit_tag_before,Kind}}});
+	    asn1_error(S, {implicit_tag_before,Kind});
 	[ChTag = #tag{type={default,_}}|T] -> 
 	    case Kind of
 		open_type ->
@@ -3470,19 +2930,24 @@ merged_mod(S,RefMod,Ext) ->
 %% any UNIQUE field, so that a component relation constraint cannot specify
 %% the type of a typefield, return 'ASN1_OPEN_TYPE'.
 %% 
-maybe_open_type(S,ClassSpec=#objectclass{fields=Fs},
-		OCFT=#'ObjectClassFieldType'{fieldname=FieldRefList},
+maybe_open_type(_, _, #'ObjectClassFieldType'{fieldname={_,_}}=OCFT, _) ->
+    %% Already converted.
+    OCFT;
+maybe_open_type(S, #objectclass{fields=Fs}=ClassSpec,
+		#'ObjectClassFieldType'{fieldname=FieldRefList}=OCFT,
 		Constr) ->
-    Type = get_ObjectClassFieldType(S,Fs,FieldRefList),
-    FieldNames=get_referenced_fieldname(FieldRefList),
-    case last_fieldname(FieldRefList) of
+    Type = get_OCFType(S, Fs, FieldRefList),
+    FieldNames = get_referenced_fieldname(FieldRefList),
+    case lists:last(FieldRefList) of
 	{valuefieldreference,_} ->
 	    OCFT#'ObjectClassFieldType'{fieldname=FieldNames,
 					type=Type};
 	{typefieldreference,_} ->
-	    case {catch get_unique_fieldname(S,#classdef{typespec=ClassSpec}),
-		  asn1ct_gen:get_constraint(Constr,componentrelation)}of
-		{Tuple,_} when tuple_size(Tuple) =:= 3 ->
+	    %% Note: The constraints have not been checked yet,
+	    %% so we must use a special lookup routine.
+	    case {get_unique_fieldname(S, #classdef{typespec=ClassSpec}),
+		  get_componentrelation(Constr)} of
+		{no_unique,_} ->
 		    OCFT#'ObjectClassFieldType'{fieldname=FieldNames,
 						type='ASN1_OPEN_TYPE'};
 		{_,no} ->
@@ -3494,16 +2959,12 @@ maybe_open_type(S,ClassSpec=#objectclass{fields=Fs},
 	    end
     end.
 
-last_fieldname(FieldRefList) when is_list(FieldRefList) ->
-    lists:last(FieldRefList);
-last_fieldname({FieldName,_}) when is_atom(FieldName) ->
-    [A|_] = atom_to_list(FieldName),
-    case is_lowercase(A) of
-	true ->
-	    {valuefieldreference,FieldName};
-	_ ->
-	    {typefieldreference,FieldName}
-    end.
+get_componentrelation([{element_set,{componentrelation,_,_}=Cr,none}|_]) ->
+    Cr;
+get_componentrelation([_|T]) ->
+    get_componentrelation(T);
+get_componentrelation([]) ->
+    no.
 
 is_open_type(#'ObjectClassFieldType'{type='ASN1_OPEN_TYPE'}) ->
     true;
@@ -3542,35 +3003,19 @@ notify_if_not_ptype(S,#pobjectsetdef{class=Cl}) ->
 	_ ->
 	    throw(pobjectsetdef)
     end;
-notify_if_not_ptype(_S,PT) ->
-    throw({error,{"supposed to be a parameterized type",PT}}).
-% fix me
+notify_if_not_ptype(S, PT) ->
+    asn1_error(S, {param_bad_type, error_value(PT)}).
+
 instantiate_ptype(S,Ptypedef,ParaList) ->
     #ptypedef{args=Args,typespec=Type} = Ptypedef,
     NewType = check_ptype(S,Ptypedef,Type#type{inlined=yes}),    
     MatchedArgs = match_args(S,Args, ParaList, []),
     OldArgs = S#state.parameters,
-    NewS = S#state{type=NewType,parameters=MatchedArgs++OldArgs,abscomppath=[]},
-%%    NewS = S#state{type=NewType,parameters=MatchedArgs,abscomppath=[]},
+    NewS = S#state{parameters=MatchedArgs++OldArgs,abscomppath=[]},
     check_type(NewS, Ptypedef#ptypedef{typespec=NewType}, NewType).
 
-get_datastr_name(#typedef{name=N}) ->
-    N;
-get_datastr_name(#classdef{name=N}) ->
-    N;
-get_datastr_name(#valuedef{name=N}) ->
-    N;
-get_datastr_name(#ptypedef{name=N}) ->
-    N;
-get_datastr_name(#pvaluedef{name=N}) ->
-    N;
-get_datastr_name(#pvaluesetdef{name=N}) ->
-    N;
-get_datastr_name(#pobjectdef{name=N}) ->
-    N;
-get_datastr_name(#pobjectsetdef{name=N}) ->
-    N.
-
+get_datastr_name(Type) ->
+    asn1ct:get_name_of_def(Type).
 
 get_pt_args(#ptypedef{args=Args}) ->
     Args;
@@ -3638,116 +3083,56 @@ match_args(S,FA = [FormArg|Ft], AA = [ActArg|At], Acc) ->
     end;
 match_args(_S,[], [], Acc) ->
     lists:reverse(Acc);
-match_args(_,_, _, _) ->
-    throw({error,{asn1,{wrong_number_of_arguments}}}).
+match_args(S, _, _, _) ->
+    asn1_error(S, param_wrong_number_of_arguments).
 
 %%%%%%%%%%%%%%%%%
 %% categorize_arg(S,FormalArg,ActualArg) -> {FormalArg,CatgorizedActualArg}
 %%
 categorize_arg(S,{Governor,Param},ActArg) ->
-    case {governor_category(S,Governor),parameter_name_style(Param,ActArg)} of
-%% 	{absent,beginning_uppercase} -> %% a type
-%% 	    categorize(S,type,ActArg);
-	{type,beginning_lowercase} -> %% a value
-	    categorize(S,value,Governor,ActArg);
-	{type,beginning_uppercase} -> %% a value set
-	    categorize(S,value_set,ActArg);
-%% 	{absent,entirely_uppercase} -> %% a class
-%% 	    categorize(S,class,ActArg);
+    case {governor_category(S, Governor),parameter_name_style(Param)} of
+	{type,beginning_lowercase} ->		%a value
+	    categorize(S, value, Governor, ActArg);
+	{type,beginning_uppercase} ->		%a value set
+	    categorize(ActArg);
 	{{class,ClassRef},beginning_lowercase} -> 
-	    categorize(S,object,ActArg,ClassRef);
+	    categorize(S, object, ActArg, ClassRef);
 	{{class,ClassRef},beginning_uppercase} ->
-	    categorize(S,object_set,ActArg,ClassRef);
-	_ ->
-	    [ActArg]
+	    categorize(S, object_set, ActArg, ClassRef)
     end;
-categorize_arg(S,FormalArg,ActualArg) ->
-    %% governor is absent => a type or a class
-    case FormalArg of
-	#'Externaltypereference'{type=Name} ->
-	    case is_class_name(Name) of
-		true ->
-		    categorize(S,class,ActualArg);
-		_ ->
-		    categorize(S,type,ActualArg)
-	    end;
-	FA ->
-	    throw({error,{unexpected_formal_argument,FA}})
-    end.
-
-governor_category(S,#type{def=Eref}) 
-  when is_record(Eref,'Externaltypereference') ->   
-    governor_category(S,Eref);
-governor_category(_S,#type{}) ->
+categorize_arg(_S, _FormalArg, ActualArg) ->
+    %% Governor is absent -- must be a type or a class. We have already
+    %% checked that the FormalArg begins with an uppercase letter.
+    categorize(ActualArg).
+
+%% governor_category(S, Item) -> type | {class,#'Externaltypereference'{}}
+%%  Determine whether Item is a type or a class.
+governor_category(S, #type{def=#'Externaltypereference'{}=Eref}) ->
+    governor_category(S, Eref);
+governor_category(_S, #type{}) ->
     type;
-governor_category(S,Ref) when is_record(Ref,'Externaltypereference') ->
-    case is_class(S,Ref) of
-	true ->
-	    {class,Ref};
-	_ ->
+governor_category(S, #'Externaltypereference'{}=Ref) ->
+    case get_class_def(S, Ref) of
+	#classdef{pos=Pos,module=Mod,name=Name} ->
+	    {class,#'Externaltypereference'{pos=Pos,module=Mod,type=Name}};
+	none ->
 	    type
-    end;
-governor_category(_,Class) 
-  when Class == 'TYPE-IDENTIFIER'; Class == 'ABSTRACT-SYNTAX' ->
-    class.
-%% governor_category(_,_) ->
-%%     absent.
+    end.
 
 %% parameter_name_style(Param,Data) -> Result
 %% gets the Parameter and the name of the Data and if it exists tells
 %% whether it begins with a lowercase letter or is partly or entirely
 %% spelled with uppercase letters. Otherwise returns undefined
 %%
-parameter_name_style(_,#'Externaltypereference'{type=Name}) ->
-    name_category(Name);
-parameter_name_style(_,#'Externalvaluereference'{value=Name}) ->
-    name_category(Name);
-parameter_name_style(_,{valueset,_}) ->
-    %% It is a object set or value set
+parameter_name_style(#'Externaltypereference'{}) ->
     beginning_uppercase;
-parameter_name_style(#'Externalvaluereference'{},_) ->
-    beginning_lowercase;
-parameter_name_style(#'Externaltypereference'{type=Name},_) ->
-    name_category(Name);
-parameter_name_style(_,_) ->
-    undefined.
+parameter_name_style(#'Externalvaluereference'{}) ->
+    beginning_lowercase.
 
-name_category(Atom) when is_atom(Atom) ->
-    name_category(atom_to_list(Atom));
-name_category([H|T]) ->
-    case is_lowercase(H) of
-	true ->
-	    beginning_lowercase;
-	_ ->
-	    case is_class_name(T) of
-		true ->
-		    entirely_uppercase;
-		_ ->
-		    beginning_uppercase
-	    end
-    end;
-name_category(_) ->
-    undefined.
-
-is_lowercase(X) when X >= $A,X =< $W ->
-    false;
-is_lowercase(_) ->
-    true.
-
-is_class_name(Name) when is_atom(Name) ->
-    is_class_name(atom_to_list(Name));
-is_class_name(Name) ->
-    case [X||X <- Name, X >= $a,X =< $w] of
-	[] ->
-	    true;
-	_ ->
-	    false
-    end.
-		
-%% categorize(S,Category,Parameter) -> CategorizedParameter
+%% categorize(Parameter) -> CategorizedParameter
 %% If Parameter has an abstract syntax of another category than
 %% Category, transform it to a known syntax.
-categorize(_S,type,{object,_,Type}) ->
+categorize({object,_,Type}) ->
     %% One example of this case is an object with a parameterized type
     %% having a locally defined type as parameter.
     Def = fun(D = #type{}) ->
@@ -3759,11 +3144,12 @@ categorize(_S,type,{object,_,Type}) ->
 		  D
 	  end,
     [Def(X)||X<-Type];
-categorize(_S,type,Def) when is_record(Def,type) ->
+categorize(#type{}=Def) ->
     [#typedef{name = new_reference_name("type_argument"),
 	      typespec = Def#type{inlined=yes}}];
-categorize(_,_,Def) ->
+categorize(Def) ->
     [Def].
+
 categorize(S,object_set,Def,ClassRef) ->
     NewObjSetSpec = 
 	check_object(S,Def,#'ObjectSet'{class = ClassRef,
@@ -3791,757 +3177,503 @@ parse_objectset(Set) ->
     Set.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% check_constraints/2
-%%    
-check_constraints(S,C) when is_list(C) -> 
-    check_constraints(S, C, []).
-
-resolv_tuple_or_list(S,List) when is_list(List) ->
-    lists:map(fun(X)->resolv_value(S,X) end, List);
-resolv_tuple_or_list(S,{Lb,Ub}) ->
-    {resolv_value(S,Lb),resolv_value(S,Ub)}.
-
-%%%-----------------------------------------
-%% If the constraint value is a defined value the valuename
-%% is replaced by the actual value
 %%
-resolv_value(S,Val) ->
-    Id = match_parameters(S,Val, S#state.parameters),
-    resolv_value1(S,Id).
+%% Check and simplify constraints.
+%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-resolv_value1(S, ERef = #'Externalvaluereference'{value=Name}) ->
-    case catch resolve_namednumber(S,S#state.type,Name) of
-	V when is_integer(V) -> V;
-	_ ->
-	    case get_referenced_type(S,ERef) of
-		{Err,_Reason} when Err == error; Err == 'EXIT' ->
-		    throw({error,{asn1,{undefined_type_or_value,
-				Name}}});
-		{_M,VDef} ->
-		    resolv_value1(S,VDef)
-	    end
-    end;
-resolv_value1(S, {gt,V}) ->
-    case resolv_value1(S, V) of
-	Int when is_integer(Int) ->
-	    Int + 1;
-	Other ->
-	    throw({error,{asn1,{not_integer_value,Other}}})
-    end;
-resolv_value1(S, {lt,V}) ->
-    case resolv_value1(S, V) of
-	Int when is_integer(Int) ->
-	    Int - 1;
-	Other ->
-	    throw({error,{asn1,{not_integer_value,Other}}})
-    end;
-resolv_value1(S,{'ValueFromObject',{object,Object},[{valuefieldreference,
-						     FieldName}]}) ->
-    %% FieldName can hold either a fixed-type value or a variable-type value
-    %% Object is a DefinedObject, i.e. a #'Externaltypereference'
-    resolve_value_from_object(S,Object,FieldName);
-resolv_value1(_,#valuedef{checked=true,value=V}) ->
-    V;
-resolv_value1(S,#valuedef{type=_T,
-			  value={'ValueFromObject',{object,Object},
-				 [{valuefieldreference,
-				   FieldName}]}}) ->
-    resolve_value_from_object(S,Object,FieldName);
-resolv_value1(S,VDef = #valuedef{}) ->
-    #valuedef{value=Val} = check_value(S,VDef),
-    Val;
-resolv_value1(_,V) ->
-    V.
-resolve_value_from_object(S,Object,FieldName) ->
-    {_,ObjTDef} = get_referenced_type(S,Object),
-    TS = check_object(S,ObjTDef,ObjTDef#typedef.typespec),
-    {_,_,Components} = TS#'Object'.def,
-    case lists:keysearch(FieldName,1,Components) of
-	{value,{_,#valuedef{value=Val}}} ->
-	    Val;
-	_ ->
-	    error({value,"illegal value in constraint",S})
+check_constraints(_S, _HostType, []) ->
+    [];
+check_constraints(S, HostType0, [_|_]=Cs0) ->
+    HostType = get_real_host_type(HostType0, Cs0),
+    Cs1 = top_level_intersections(Cs0),
+    Cs2 = [coalesce_constraints(C) || C <- Cs1],
+    {_,Cs3} = filter_extensions(Cs2),
+    Cs = simplify_element_sets(S, HostType, Cs3),
+    finish_constraints(Cs).
+
+get_real_host_type(HostType, Cs) ->
+    case lists:keyfind(ocft, 1, Cs) of
+	false -> HostType;
+	{_,OCFT} -> HostType#type{def=OCFT}
     end.
 
+top_level_intersections([{element_set,{intersection,_,_}=C,none}]) ->
+    top_level_intersections_1(C);
+top_level_intersections(Cs) ->
+    Cs.
+
+top_level_intersections_1({intersection,A,B}) ->
+    [{element_set,A,none}|top_level_intersections_1(B)];
+top_level_intersections_1(Other) ->
+    [{element_set,Other,none}].
+
+coalesce_constraints({element_set,
+		  {Tag,{element_set,A,_}},
+		  {Tag,{element_set,B,_}}}) ->
+    %% (SIZE (C1), ..., (SIZE (C2)) => (SIZE (C1, ..., C2))
+    {element_set,{Tag,{element_set,A,B}},none};
+coalesce_constraints(Other) ->
+    Other.
+
+%% Remove all outermost extensions except the last.
+
+filter_extensions([H0|T0]) ->
+    case filter_extensions(T0) of
+	{true,T} ->
+	    H = remove_extension(H0),
+	    {true,[H|T]};
+	{false,T} ->
+	    {any_extension(H0),[H0|T]}
+    end;
+filter_extensions([]) ->
+    {false,[]}.
 
+remove_extension({element_set,Root,_}) ->
+    {element_set,remove_extension(Root),none};
+remove_extension(Tuple) when is_tuple(Tuple) ->
+    L = [remove_extension(El) || El <- tuple_to_list(Tuple)],
+    list_to_tuple(L);
+remove_extension(Other) -> Other.
 
-resolve_namednumber(S,#typedef{typespec=Type},Name) ->
-    case Type#type.def of
-	{'ENUMERATED',NameList} ->
-	    NamedNumberList=check_enumerated(S,NameList,Type#type.constraint),
-	    N = normalize_enumerated(S,Name,NamedNumberList),
-	    {value,{_,V}} = lists:keysearch(N,1,NamedNumberList),
-	    V;
-	{'INTEGER',NameList} ->
-	    NamedNumberList = check_enumerated(S,NameList,Type#type.constraint),
-	    {value,{_,V}} = lists:keysearch(Name,1,NamedNumberList),
-	    V;
+any_extension({element_set,_,Ext}) when Ext =/= none ->
+    true;
+any_extension(Tuple) when is_tuple(Tuple) ->
+    any_extension_tuple(1, Tuple);
+any_extension(_) -> false.
+
+any_extension_tuple(I, T) when I =< tuple_size(T) ->
+    any_extension(element(I, T)) orelse any_extension_tuple(I+1, T);
+any_extension_tuple(_, _) -> false.
+
+simplify_element_sets(S, HostType, [{element_set,R0,E0}|T0]) ->
+    R1 = simplify_element_set(S, HostType, R0),
+    E1 = simplify_element_set(S, HostType, E0),
+    case simplify_element_sets(S, HostType, T0) of
+	[{element_set,R2,E2}] ->
+	    [{element_set,cs_intersection(S, R1, R2),
+	      cs_intersection(S, E1, E2)}];
+	L when is_list(L) ->
+	    [{element_set,R1,E1}|L]
+    end;
+simplify_element_sets(S, HostType, [H|T]) ->
+    [H|simplify_element_sets(S, HostType, T)];
+simplify_element_sets(_, _, []) ->
+    [].
+
+simplify_element_set(_S, _HostType, empty) ->
+    {set,[]};
+simplify_element_set(S, HostType, {'SingleValue',Vs0}) when is_list(Vs0) ->
+    Vs1 = [resolve_value(S, HostType, V) || V <- Vs0],
+    Vs = make_constr_set_vs(Vs1),
+    simplify_element_set(S, HostType, Vs);
+simplify_element_set(S, HostType, {'SingleValue',V0}) ->
+    V1 = resolve_value(S, HostType, V0),
+    V = {set,[{range,V1,V1}]},
+    simplify_element_set(S, HostType, V);
+simplify_element_set(S, HostType, {'ValueRange',{Lb0,Ub0}}) ->
+    Lb = resolve_value(S, HostType, Lb0),
+    Ub = resolve_value(S, HostType, Ub0),
+    V = make_constr_set(S, Lb, Ub),
+    simplify_element_set(S, HostType, V);
+simplify_element_set(S, HostType, {'ALL-EXCEPT',Set0}) ->
+    Set = simplify_element_set(S, HostType, Set0),
+    {'ALL-EXCEPT',Set};
+simplify_element_set(S, HostType, {intersection,A0,B0}) ->
+    A = simplify_element_set(S, HostType, A0),
+    B = simplify_element_set(S, HostType, B0),
+    cs_intersection(S, A, B);
+simplify_element_set(S, HostType, {union,A0,B0}) ->
+    A = simplify_element_set(S, HostType, A0),
+    B = simplify_element_set(S, HostType, B0),
+    cs_union(S, A, B);
+simplify_element_set(S, HostType, {simpletable,{element_set,Type,_}}) ->
+    check_simpletable(S, HostType, Type);
+simplify_element_set(S, _, {componentrelation,R,Id}) ->
+    check_componentrelation(S, R, Id);
+simplify_element_set(S, HostType, {Tag,{element_set,_,_}=El0}) ->
+    [El1] = simplify_element_sets(S, HostType, [El0]),
+    {Tag,El1};
+simplify_element_set(S, HostType, #type{}=Type) ->
+    simplify_element_set_type(S, HostType, Type);
+simplify_element_set(_, _, C) ->
+    C.
+
+simplify_element_set_type(S, HostType, #type{def=Def0}=Type0) ->
+    #'Externaltypereference'{} = Def0,		%Assertion.
+    case get_referenced_type(S, Def0) of
+	{_,#valuedef{checked=false,value={valueset,Vs0}}} ->
+	    [Vs1] = simplify_element_sets(S, HostType, [Vs0]),
+	    case Vs1 of
+		{element_set,Set,none} ->
+		    Set;
+		{element_set,Set,{set,[]}} ->
+		    Set
+	    end;
+	{_,{valueset,#type{def=#'Externaltypereference'{}}=Type}} ->
+	    simplify_element_set_type(S, HostType, Type);
 	_ ->
-	    not_enumerated
+	    case HostType of
+		#type{def=#'ObjectClassFieldType'{}} ->
+		    %% Open type.
+		    #type{def=Def} = check_type(S, HostType, Type0),
+		    Def;
+		_ ->
+		    #type{constraint=Cs} = check_type(S, HostType, Type0),
+		    C = convert_back(Cs),
+		    simplify_element_set(S, HostType, C)
+	    end
     end.
-    
-check_constraints(S,[{'ContainedSubtype',Type} | Rest], Acc) ->
-    {RefMod,CTDef} = get_referenced_type(S,Type#type.def),
-    NewS = S#state{module=load_asn1_module(S,RefMod),mname=RefMod,
-		   type=CTDef,tname=get_datastr_name(CTDef)},
-    CType = check_type(NewS,S#state.tname,CTDef#typedef.typespec),    
-    check_constraints(S,Rest,CType#type.constraint ++ Acc);
-check_constraints(S,[C | Rest], Acc) ->
-    check_constraints(S,Rest,[check_constraint(S,C) | Acc]);
-check_constraints(S,[],Acc) ->
-    constraint_merge(S,Acc).
-
-
-range_check(F={FixV,FixV}) ->
-%    FixV;
-    F;
-range_check(VR={Lb,Ub}) when Lb < Ub ->
-    VR;
-range_check(Err={_,_}) ->
-    throw({error,{asn1,{illegal_size_constraint,Err}}});
-range_check(Value) ->
-    Value.
 
-check_constraint(S,Ext) when is_record(Ext,'Externaltypereference') ->
-    check_externaltypereference(S,Ext);
-
-
-check_constraint(S,{'SizeConstraint',{Lb,Ub}}) 
-  when is_list(Lb); tuple_size(Lb) =:= 2 ->
-    NewLb = range_check(resolv_tuple_or_list(S,Lb)),
-    NewUb = range_check(resolv_tuple_or_list(S,Ub)),
-    {'SizeConstraint',{NewLb,NewUb}};
-check_constraint(S,{'SizeConstraint',{Lb,Ub}}) ->
-    case {resolv_value(S,Lb),resolv_value(S,Ub)} of
-	{FixV,FixV} ->
-	    {'SizeConstraint',FixV};
-	{Low,High} when Low < High ->
-	    {'SizeConstraint',{Low,High}};
-	Err ->
-	    throw({error,{asn1,{illegal_size_constraint,Err}}})
-    end;
-check_constraint(S,{'SizeConstraint',Lb}) ->
-    {'SizeConstraint',resolv_value(S,Lb)};
+convert_back([H1,H2|T]) ->
+   {intersection,H1,convert_back([H2|T])};
+convert_back([H]) ->
+    H;
+convert_back([]) ->
+    none.
 
-check_constraint(S,{'SingleValue', L}) when is_list(L) ->
-    F = fun(A) -> resolv_value(S,A) end,
-    {'SingleValue',lists:sort(lists:map(F,L))};
-    
-check_constraint(S,{'SingleValue', V}) when is_integer(V) ->
-    Val = resolv_value(S,V),
-%%    [{'SingleValue',Val},{'ValueRange',{Val,Val}}]; % Why adding value range?
-    {'SingleValue',Val};
-check_constraint(S,{'SingleValue', V}) ->
-    {'SingleValue',resolv_value(S,V)};
-
-check_constraint(S,{'ValueRange', {Lb, Ub}}) ->
-    {'ValueRange',{resolv_value(S,Lb),resolv_value(S,Ub)}};
-%% In case of a constraint with extension marks like (1..Ub,...)
-check_constraint(S,{VR={'ValueRange', {_Lb, _Ub}},Rest}) ->
-    {check_constraint(S,VR),Rest};
-check_constraint(_S,{'PermittedAlphabet',PA}) ->
-    {'PermittedAlphabet',permitted_alphabet_cnstr(PA)};
-
-check_constraint(S,{valueset,Type}) ->
-    {valueset,check_type(S,S#state.tname,Type)};
-
-check_constraint(_S,ST={simpletable,Type}) when is_atom(Type) ->
-    %% An already checked constraint
-    ST;
-check_constraint(S,{simpletable,Type}) ->
+check_simpletable(S, HostType, Type) ->
+    case HostType of
+	#type{def=#'ObjectClassFieldType'{}} ->
+	    ok;
+	_ ->
+	    %% Table constraints may only be applied to
+	    %% CLASS.&field constructs.
+	    asn1_error(S, illegal_table_constraint)
+    end,
     Def = case Type of
 	      #type{def=D} -> D;
-	      {'SingleValue',ObjRef = #'Externalvaluereference'{}} ->
-		  ObjRef
+	      {'SingleValue',#'Externalvaluereference'{}=ObjRef} ->
+		  ObjRef;
+	      _ ->
+		  asn1_error(S, invalid_table_constraint)
 	  end,
-    C = match_parameters(S,Def,S#state.parameters),
+    C = match_parameter(S, Def),
     case C of
 	#'Externaltypereference'{} ->
-	    ERef = check_externaltypereference(S,C),
+	    ERef = check_externaltypereference(S, C),
 	    {simpletable,ERef#'Externaltypereference'.type};
-	#type{def=#'Externaltypereference'{type=T}} ->
-	    check_externaltypereference(S,C#type.def),
-	    {simpletable,T};
-	{valueset,#type{def=ERef=#'Externaltypereference'{}}} -> % this is an object set
-	    {_,TDef} = get_referenced_type(S,ERef),
-	    case TDef#typedef.typespec of 
-		#'ObjectSet'{} ->
-		    check_object(S,TDef,TDef#typedef.typespec),
-		    {simpletable,ERef#'Externaltypereference'.type};
-		Err ->
-		    exit({error,{internal_error,Err}})
-	    end;
 	#'Externalvaluereference'{} ->
 	    %% This is an object set with a referenced object
-	    {_,TorVDef} = get_referenced_type(S,C),
-	    GetObjectSet = 
-		fun(#typedef{typespec=O}) when is_record(O,'Object') ->
-			#'ObjectSet'{class=O#'Object'.classname,
-				     set={'SingleValue',C}};
-		   (#valuedef{type=Cl,value=O}) 
-		   when is_record(O,'Externalvaluereference'),
-			is_record(Cl,type) ->
-			%% an object might reference another object
-			#'ObjectSet'{class=Cl#type.def,
-				     set={'SingleValue',O}};
-		   (Err) -> 
-			exit({error,{internal_error,simpletable_constraint,Err}})
-		end,
-	    ObjSet = GetObjectSet(TorVDef),
-	    {simpletable,check_object(S,Type,ObjSet)};
-	#'ObjectSet'{} ->
-	    io:format("ALERT: simpletable forbidden case!~n",[]),
-	    {simpletable,check_object(S,Type,C)};
-	{'ValueFromObject',{_,ORef},FieldName} ->
-	    %% This is an ObjectFromObject
-	    {_,Object} = get_referenced_type(S,ORef),
-	    ChObject = check_object(S,Object,
-				    Object#typedef.typespec),
-	    ObjFromObj=
-		get_fieldname_element(S,Object#typedef{
-					  typespec=ChObject},
-				      FieldName),
-	    {simpletable,ObjFromObj};
-%% 	     ObjFromObj#typedef{checked=true,typespec=
-%% 				check_object(S,ObjFromObj,
-%% 					     ObjFromObj#typedef.typespec)}};
-	_ -> 
-	    check_type(S,S#state.tname,Type),%% this seems stupid.
-	    OSName = Def#'Externaltypereference'.type,
-	    {simpletable,OSName}
-    end;
+	    {_,TorVDef} = get_referenced_type(S, C),
+	    Set = case TorVDef of
+		      #typedef{typespec=#'Object'{classname=ClassName}} ->
+			  #'ObjectSet'{class=ClassName,
+				       set={'SingleValue',C}};
+		      #valuedef{type=#type{def=ClassDef},
+				value=#'Externalvaluereference'{}=Obj} ->
+			  %% an object might reference another object
+			  #'ObjectSet'{class=ClassDef,
+				       set={'SingleValue',Obj}}
+		  end,
+	    {simpletable,check_object(S, Type, Set)};
+	{'ValueFromObject',{_,Object},FieldNames} ->
+	    %% This is an ObjectFromObject.
+	    {simpletable,extract_field(S, Object, FieldNames)}
+    end.
 
-check_constraint(S,{componentrelation,{objectset,Opos,Objset},Id}) ->
+check_componentrelation(S, {objectset,Opos,Objset0}, Id) ->
     %% Objset is an 'Externaltypereference' record, since Objset is
     %% a DefinedObjectSet.
-    RealObjset = match_parameters(S,Objset,S#state.parameters),
-    ObjSetRef =
-	case RealObjset of
-	    #'Externaltypereference'{} -> RealObjset;
-	    #type{def=#'Externaltypereference'{}} -> RealObjset#type.def;
-	    {valueset,OS = #type{def=#'Externaltypereference'{}}} -> OS#type.def
-	end,
-    Ext = check_externaltypereference(S,ObjSetRef),
-    {componentrelation,{objectset,Opos,Ext},Id};
+    ObjSet = match_parameter(S, Objset0),
+    Ext = check_externaltypereference(S, ObjSet),
+    {componentrelation,{objectset,Opos,Ext},Id}.
+
+%%%
+%%% Internal set representation.
+%%%
+%%% We represent sets as a union of strictly disjoint ranges:
+%%%
+%%%   {set,[Range]}
+%%%
+%%% A range is represented as:
+%%%
+%%%   Range = {a_range,UpperBound} | {range,LowerBound,UpperBound}
+%%%
+%%% We don't use the atom 'MIN' to represent MIN, because atoms
+%%% compare higher than integer. Instead we use {a_range,UpperBound}
+%%% to represent MIN..UpperBound. We represent MAX as 'MAX' because
+%%% 'MAX' compares higher than any integer.
+%%%
+%%% The ranges are sorted in term order. The ranges must not overlap
+%%% or be adjacent to each other. This invariant is established when
+%%% creating sets, and maintained by the intersection and union
+%%% operators.
+%%%
+%%% Example of invalid set representaions:
+%%%
+%%%   [{range,0,10},{range,5,10}]    %Overlapping ranges
+%%%   [{range,0,5},{range,6,10}]     %Adjancent ranges
+%%%   [{range,10,20},{a_range,100}]  %Not sorted
+%%%
+
+make_constr_set(_, 'MIN', Ub) ->
+    {set,[{a_range,make_constr_set_val(Ub)}]};
+make_constr_set(_, Lb, Ub) when Lb =< Ub ->
+    {set,[{range,make_constr_set_val(Lb),
+	   make_constr_set_val(Ub)}]};
+make_constr_set(S, _, _) ->
+    asn1_error(S, reversed_range).
+
+make_constr_set_val([C]) when is_integer(C) -> C;
+make_constr_set_val(Val) -> Val.
+
+make_constr_set_vs(Vs) ->
+    {set,make_constr_set_vs_1(Vs)}.
+
+make_constr_set_vs_1([]) ->
+    [];
+make_constr_set_vs_1([V]) ->
+    [{range,V,V}];
+make_constr_set_vs_1([V0|Vs]) ->
+    V1 = make_constr_set_vs_1(Vs),
+    range_union([{range,V0,V0}], V1).
+
+%%%
+%%% Set operators.
+%%%
+
+cs_intersection(_S, Other, none) ->
+    Other;
+cs_intersection(_S, none, Other) ->
+    Other;
+cs_intersection(_S, {set,SetA}, {set,SetB}) ->
+    {set,range_intersection(SetA, SetB)};
+cs_intersection(_S, A, B) ->
+    {intersection,A,B}.
+
+range_intersection([], []) ->
+    [];
+range_intersection([_|_], []) ->
+    [];
+range_intersection([], [_|_]) ->
+    [];
+range_intersection([H1|_]=A, [H2|_]=B) when H1 > H2 ->
+    range_intersection(B, A);
+range_intersection([H1|T1], [H2|T2]=B) ->
+    %% Now H1 =< H2.
+    case {H1,H2} of
+	{{a_range,Ub0},{a_range,Ub1}} when Ub0 < Ub1 ->
+	    %% Ub0 =/= 'MAX'
+	    [H1|range_intersection(T1, [{range,Ub0+1,Ub1}|T2])];
+	{{a_range,_},{a_range,_}} ->
+	    %% Must be equal.
+	    [H1|range_intersection(T1, T2)];
+	{{a_range,Ub0},{range,Lb1,_Ub1}} when Ub0 < Lb1 ->
+	    %% No intersection.
+	    range_intersection(T1, B);
+	{{a_range,Ub0},{range,Lb1,Ub1}} when Ub0 < Ub1 ->
+	    %% Ub0 =/= 'MAX'
+	    [{range,Lb1,Ub0}|range_intersection(T1, [{range,Ub0+1,Ub1}|T2])];
+	{{a_range,Ub},{range,_Lb1,Ub}} ->
+	    %% The first range covers the second range, but does not
+	    %% go beyond. We handle this case specially because Ub may
+	    %% be 'MAX', and evaluating 'MAX'+1 will fail.
+	    [H2|range_intersection(T1, T2)];
+	{{a_range,Ub0},{range,_Lb1,Ub1}} ->
+	    %% Ub0 > Ub1, Ub1 =/= 'MAX'. The first range completely
+	    %% covers and extends beyond the second range.
+	    [H2|range_intersection([{range,Ub1+1,Ub0}|T1], T2)];
+	{{range,_Lb0,Ub0},{range,Lb1,_Ub1}} when Ub0 < Lb1 ->
+	    %% Lb0 < Lb1. No intersection.
+	    range_intersection(T1, B);
+	{{range,_Lb0,Ub0},{range,Lb1,Ub1}} when Ub0 < Ub1 ->
+	    %% Ub0 >= Lb1, Ub0 =/= 'MAX'. Partial overlap.
+	    [{range,Lb1,Ub0}|range_intersection(T1, [{range,Ub0+1,Ub1}|T2])];
+	{{range,_Lb0,Ub},{range,_Lb1,Ub}} ->
+	    %% The first range covers the second range, but does not
+	    %% go beyond. We handle this case specially because Ub may
+	    %% be 'MAX', and evaluating 'MAX'+1 will fail.
+	    [H2|range_intersection(T1, T2)];
+	{{range,_Lb0,Ub0},{range,_Lb1,Ub1}} ->
+	    %% Ub1 =/= MAX. The first range completely covers and
+	    %% extends beyond the second.
+	    [H2|range_intersection([{range,Ub1+1,Ub0}|T1], T2)]
+    end.
 
-check_constraint(S,Type) when is_record(Type,type) ->
-    #type{def=Def} = check_type(S,S#state.tname,Type),
-    Def;
+cs_union(_S, {set,SetA}, {set,SetB}) ->
+    {set,range_union(SetA, SetB)};
+cs_union(_S, A, B) ->
+    {union,A,B}.
+
+range_union(A, B) ->
+    range_union_1(lists:merge(A, B)).
+
+range_union_1([{a_range,Ub0},{a_range,Ub1}|T]) ->
+    range_union_1([{a_range,max(Ub0, Ub1)}|T]);
+range_union_1([{a_range,Ub0},{range,Lb1,Ub1}|T]) when Lb1-1 =< Ub0 ->
+    range_union_1([{a_range,max(Ub0, Ub1)}|T]);
+range_union_1([{a_range,_}=H|T]) ->
+    %% Ranges are disjoint.
+    [H|range_union_1(T)];
+range_union_1([{range,Lb0,Ub0},{range,Lb1,Ub1}|T]) when Lb1-1 =< Ub0 ->
+    range_union_1([{range,Lb0,max(Ub0, Ub1)}|T]);
+range_union_1([{range,_,_}=H|T]) ->
+    %% Ranges are disjoint.
+    [H|range_union_1(T)];
+range_union_1([]) ->
+    [].
 
-check_constraint(S,C) when is_list(C) ->
-    lists:map(fun(X)->check_constraint(S,X) end,C);
-% else keep the constraint unchanged
-check_constraint(_S,Any) ->
-%    io:format("Constraint = ~p~n",[Any]),
-    Any.
-
-permitted_alphabet_cnstr(T) when is_tuple(T) ->
-    permitted_alphabet_cnstr([T]);
-permitted_alphabet_cnstr(L) when is_list(L) ->
-    VRexpand = fun({'ValueRange',{A,B}}) ->
-		       {'SingleValue',expand_valuerange(A,B)};
-		  (Other) ->
-		       Other
-	       end,
-    L2 = lists:map(VRexpand,L),
-    %% first perform intersection
-    L3 = permitted_alphabet_intersection(L2),
-    [Res] = permitted_alphabet_union(L3),
-    Res.
+%%%
+%%% Finish up constrains, making them suitable for the back-ends.
+%%%
+%%% A 'PermittedAlphabet' (FROM) constraint will be reduced to:
+%%%
+%%%   {'SingleValue',[integer()]}
+%%%
+%%% A 'SizeConstraint' (SIZE) constraint will be reduced to:
+%%%
+%%%   {Lb,Ub}
+%%%
+%%% All other constraints will be reduced to:
+%%%
+%%%   {'SingleValue',[integer()]} | {'ValueRange',Lb,Ub}
+%%%
+
+finish_constraints(Cs) ->
+    finish_constraints_1(Cs, fun smart_collapse/1).
+
+finish_constraints_1([{element_set,{Tag,{element_set,_,_}=Set0},none}|T],
+		     Collapse0) ->
+    Collapse = collapse_fun(Tag),
+    case finish_constraints_1([Set0], Collapse) of
+	[] ->
+	    finish_constraints_1(T, Collapse0);
+	[Set] ->
+	    [{Tag,Set}|finish_constraints_1(T, Collapse0)]
+    end;
+finish_constraints_1([{element_set,{set,[{a_range,'MAX'}]},_}|T], Collapse) ->
+    finish_constraints_1(T, Collapse);
+finish_constraints_1([{element_set,{intersection,A0,B0},none}|T], Collapse) ->
+    A = {element_set,A0,none},
+    B = {element_set,B0,none},
+    finish_constraints_1([A,B|T], Collapse);
+finish_constraints_1([{element_set,Root,Ext}|T], Collapse) ->
+    case finish_constraint(Root, Ext, Collapse) of
+	none ->
+	    finish_constraints_1(T, Collapse);
+	Constr ->
+	    [Constr|finish_constraints_1(T, Collapse)]
+    end;
+finish_constraints_1([H|T], Collapse) ->
+    [H|finish_constraints_1(T, Collapse)];
+finish_constraints_1([], _) ->
+    [].
 
-expand_valuerange([A],[A]) ->
-    [A];
-expand_valuerange([A],[B]) when A < B ->
-    [A|expand_valuerange([A+1],[B])].
+finish_constraint({set,Root0}, Ext, Collapse) ->
+    case Collapse(Root0) of
+	none -> none;
+	Root -> finish_constraint(Root, Ext, Collapse)
+    end;
+finish_constraint(Root, Ext, _Collapse) ->
+    case Ext of
+	none -> Root;
+	_ -> {Root,[]}
+    end.
 
-permitted_alphabet_intersection(C) ->
-    permitted_alphabet_merge(C,intersection, []).
+collapse_fun('SizeConstraint') ->
+    fun size_constraint_collapse/1;
+collapse_fun('PermittedAlphabet') ->
+    fun single_value_collapse/1.
 
-permitted_alphabet_union(C) ->
-    permitted_alphabet_merge(C,union, []).
+single_value_collapse(V) ->
+    {'SingleValue',ordsets:from_list(single_value_collapse_1(V))}.
 
-permitted_alphabet_merge([],_,Acc) ->
-    lists:reverse(Acc);
-permitted_alphabet_merge([{'SingleValue',L1},
-			  UorI,
-			  {'SingleValue',L2}|Rest],UorI,Acc)
-  when is_list(L1),is_list(L2) ->
-    UI = ordsets:UorI([ordsets:from_list(L1),ordsets:from_list(L2)]),
-    permitted_alphabet_merge([{'SingleValue',UI}|Rest],UorI,Acc);
-permitted_alphabet_merge([C1|Rest],UorI,Acc) ->
-    permitted_alphabet_merge(Rest,UorI,[C1|Acc]).
-
-
-%% constraint_merge/2
-%% Compute the intersection of the outermost level of the constraint list.
-%% See Dubuisson second paragraph and fotnote on page 285.
-%% If constraints with extension are included in combined constraints. The 
-%% resulting combination will have the extension of the last constraint. Thus,
-%% there will be no extension if the last constraint is without extension.
-%% The rootset of all constraints are considered in the "outermoust 
-%% intersection". See section 13.1.2 in Dubuisson.
-constraint_merge(St, Cs0) ->
-    Cs = constraint_merge_1(St, Cs0),
-    normalize_cs(Cs).
-
-normalize_cs([{'SingleValue',[V]}|Cs]) ->
-    [{'SingleValue',V}|normalize_cs(Cs)];
-normalize_cs([{'SingleValue',[_|_]=L0}|Cs]) ->
-    [H|T] = L = lists:usort(L0),
-    [case is_range(H, T) of
-	 false -> {'SingleValue',L};
-	 true -> {'ValueRange',{H,lists:last(T)}}
-     end|normalize_cs(Cs)];
-normalize_cs([{'ValueRange',{Sv,Sv}}|Cs]) ->
-    [{'SingleValue',Sv}|normalize_cs(Cs)];
-normalize_cs([{'ValueRange',{'MIN','MAX'}}|Cs]) ->
-    normalize_cs(Cs);
-normalize_cs([{'SizeConstraint',C0}|Cs]) ->
-    case normalize_size_constraint(C0) of
-	none ->
-	    normalize_cs(Cs);
-	C ->
-	    [{'SizeConstraint',C}|normalize_cs(Cs)]
-    end;
-normalize_cs([H|T]) ->
-    [H|normalize_cs(T)];
-normalize_cs([]) -> [].
+single_value_collapse_1([{range,Lb,Ub}|T]) when is_integer(Lb),
+					      is_integer(Ub) ->
+    lists:seq(Lb, Ub) ++ single_value_collapse_1(T);
+single_value_collapse_1([]) ->
+    [].
 
-%% Normalize a size constraint to make it non-ambiguous and
-%% easy to interpret for the backends.
-%%
-%% Returns one of the following terms:
-%%  {LowerBound,UpperBound}
-%%  {{LowerBound,UpperBound},[]}     % Extensible
-%%  none                             % Remove size constraint from list
-%%
-%% where:
-%%  LowerBound = integer()
-%%  UpperBound = integer() | 'MAX'
-
-normalize_size_constraint(Sv) when is_integer(Sv) ->
-    {Sv,Sv};
-normalize_size_constraint({Root,Ext}) when is_list(Ext) ->
-    {normalize_size_constraint(Root),[]};
-normalize_size_constraint({{_,_},Ext}) when is_integer(Ext) ->
-    normalize_size_constraint(Ext);
-normalize_size_constraint([H|T]) ->
-    {H,lists:last(T)};
-normalize_size_constraint({0,'MAX'}) ->
+smart_collapse([{a_range,Ub}]) ->
+    {'ValueRange',{'MIN',Ub}};
+smart_collapse([{a_range,_}|T]) ->
+    {range,_,Ub} = lists:last(T),
+    {'ValueRange',{'MIN',Ub}};
+smart_collapse([{range,Lb,Ub}]) ->
+    {'ValueRange',{Lb,Ub}};
+smart_collapse([_|_]=L) ->
+    V = lists:foldr(fun({range,Lb,Ub}, A) ->
+			    seq(Lb, Ub) ++ A
+		    end, [], L),
+    {'SingleValue',V}.
+
+size_constraint_collapse([{range,0,'MAX'}]) ->
     none;
-normalize_size_constraint({Lb,Ub}=Range)
-  when is_integer(Lb), is_integer(Ub) orelse Ub =:= 'MAX' ->
-    Range.
+size_constraint_collapse(Root) ->
+    [{range,Lb,_}|_] = Root,
+    {range,_,Ub} = lists:last(Root),
+    {Lb,Ub}.
 
-is_range(Prev, [H|T]) when Prev =:= H - 1 -> is_range(H, T);
-is_range(_, [_|_]) -> false;
-is_range(_, []) -> true.
+seq(Same, Same) ->
+    [Same];
+seq(Lb, Ub) when is_integer(Lb), is_integer(Ub) ->
+    lists:seq(Lb, Ub).
 
-constraint_merge_1(_S, [H]=C) when is_tuple(H) ->
-    C;
-constraint_merge_1(_S, []) ->
-    [];
-constraint_merge_1(S, C) ->
-    %% skip all extension but the last extension
-    C1 = filter_extensions(C),
-    %% perform all internal level intersections, intersections first
-    %% since they have precedence over unions
-    C2 = lists:map(fun(X)when is_list(X)->constraint_intersection(S,X);
-		      (X) -> X end,
-		   C1),
-    %% perform all internal level unions
-    C3 = lists:map(fun(X)when is_list(X)->constraint_union(S,X);
-		      (X) -> X end,
-		   C2),
-
-    %% now get intersection of the outermost level
-    %% get the least common single value constraint
-    SVs = get_constraints(C3,'SingleValue'),
-    CombSV = intersection_of_sv(S,SVs),
-    %% get the least common value range constraint
-    VRs = get_constraints(C3,'ValueRange'),
-    CombVR = intersection_of_vr(S,VRs),
-    %% get the least common size constraint
-    SZs = get_constraints(C3,'SizeConstraint'),
-    CombSZ = intersection_of_size(S,SZs),
-    RestC = ordsets:subtract(ordsets:from_list(C3),
-			     ordsets:from_list(SZs ++ VRs ++ SVs)),
-    %% get the least common combined constraint. That is the union of each
-    %% deep constraint and merge of single value and value range constraints.
-    %% FIXME: Removing 'intersection' from the flattened list essentially
-    %% means that intersections are converted to unions!
-    Cs = combine_constraints(S, CombSV, CombVR, CombSZ++RestC),
-    [X || X <- lists:flatten(Cs),
-	  X =/= intersection,
-	  X =/= union].
-
-%% constraint_union(S,C) takes a list of constraints as input and
-%% merge them to a union. Unions are performed when two
-%% constraints is found with an atom union between. 
-%% The list may be nested. Fix that later !!!
-constraint_union(_S,[]) ->
-    [];
-constraint_union(_S,C=[_E]) ->
-    C;
-constraint_union(S,C) when is_list(C) ->
-    case lists:member(union,C) of
-	true ->
-	    constraint_union1(S,C,[]);
-	_ ->
-	    C
-    end;
-%     SV = get_constraints(C,'SingleValue'),
-%     SV1 = constraint_union_sv(S,SV),
-%     VR = get_constraints(C,'ValueRange'),
-%     VR1 = constraint_union_vr(VR),
-%     RestC = ordsets:filter(fun({'SingleValue',_})->false;
-% 			      ({'ValueRange',_})->false;
-% 			      (_) -> true end,ordsets:from_list(C)),
-%     SV1++VR1++RestC;
-constraint_union(_S,C) ->
-    [C].
-
-constraint_union1(S,[A={'ValueRange',_},union,B={'ValueRange',_}|Rest],Acc) ->
-    AunionB = constraint_union_vr([A,B]),
-    constraint_union1(S, AunionB++Rest, Acc);
-constraint_union1(S,[A={'SingleValue',_},union,B={'SingleValue',_}|Rest],Acc) ->
-    AunionB = constraint_union_sv(S,[A,B]),
-    constraint_union1(S,Rest,Acc ++ AunionB);
-constraint_union1(S,[A={'SingleValue',_},union,B={'ValueRange',_}|Rest],Acc) ->
-    AunionB = union_sv_vr(S,A,B),
-    constraint_union1(S, AunionB++Rest, Acc);
-constraint_union1(S,[A={'ValueRange',_},union,B={'SingleValue',_}|Rest],Acc) ->
-    AunionB = union_sv_vr(S,B,A),
-    constraint_union1(S, AunionB++Rest, Acc);
-constraint_union1(S,[union|Rest],Acc) -> %skip when unsupported constraints
-    constraint_union1(S,Rest,Acc);
-constraint_union1(S,[A|Rest],Acc) ->
-    constraint_union1(S,Rest,[A|Acc]);
-constraint_union1(_S,[],Acc) ->
-    Acc.
-
-constraint_union_sv(_S,SV) ->
-    Values=lists:map(fun({_,V})->V end,SV),
-    case ordsets:from_list(Values) of
-	[] -> [];
-	[N] -> [{'SingleValue',N}];
-	L -> [{'SingleValue',L}]
-    end.
+%%%-----------------------------------------
+%% If the constraint value is a defined value the valuename
+%% is replaced by the actual value
+%%
+resolve_value(S, HostType, Val) ->
+    Id = match_parameter(S, Val),
+    resolve_value1(S, HostType, Id).
 
-%% REMOVE????
-%%constraint_union(S,VR,'ValueRange') ->
-%%    constraint_union_vr(VR).
-
-%% constraint_union_vr(VR)
-%% VR = [{'ValueRange',{Lb,Ub}},...]
-%% Lb = 'MIN' | integer()
-%% Ub = 'MAX' | integer()
-%% Returns if possible only one ValueRange tuple with a range that
-%% is a union of all ranges in VR.
-constraint_union_vr(VR) ->
-    %% Sort VR by Lb in first hand and by Ub in second hand
-    Fun=fun({_,{'MIN',_B1}},{_,{A2,_B2}}) when is_integer(A2)->true;
-	   ({_,{A1,_B1}},{_,{'MAX',_B2}}) when is_integer(A1) -> true;
-	   ({_,{A1,_B1}},{_,{A2,_B2}}) when is_integer(A1),is_integer(A2),A1<A2 -> true;
-	   ({_,{A,B1}},{_,{A,B2}}) when B1=<B2->true;
-	   (_,_)->false end,
-    SortedVR = lists:usort(Fun,VR),
-    constraint_union_vr(SortedVR, []).
-
-constraint_union_vr([],Acc) ->
-    lists:reverse(Acc);
-constraint_union_vr([C|Rest],[]) ->
-    constraint_union_vr(Rest,[C]);
-constraint_union_vr([{_,{Lb,Ub2}}|Rest],[{_,{Lb,_Ub1}}|Acc]) -> %Ub2 > Ub1
-    constraint_union_vr(Rest,[{'ValueRange',{Lb,Ub2}}|Acc]);
-constraint_union_vr([{_,{_,Ub}}|Rest],A=[{_,{_,Ub}}|_Acc]) ->
-    constraint_union_vr(Rest,A);
-constraint_union_vr([{_,{Lb2,Ub2}}|Rest], [{_,{Lb1,Ub1}}|Acc])
-  when Ub1 =< Lb2, Ub1 < Ub2 ->
-    constraint_union_vr(Rest,[{'ValueRange',{Lb1,Ub2}}|Acc]);
-constraint_union_vr([{_,{_,Ub2}}|Rest],A=[{_,{_,Ub1}}|_Acc]) when Ub2=<Ub1->
-    constraint_union_vr(Rest,A);
-constraint_union_vr([VR|Rest],Acc) ->
-    constraint_union_vr(Rest,[VR|Acc]).
-
-union_sv_vr(_S,{'SingleValue',SV},VR) 
-  when is_integer(SV) ->
-    union_sv_vr(_S,{'SingleValue',[SV]},VR);
-union_sv_vr(_S,{'SingleValue',SV},{'ValueRange',{VLb,VUb}}) 
-  when is_list(SV) ->
-    L = lists:sort(SV++[VLb,VUb]),
-    {Lb,L1} = case lists:member('MIN',L) of 
-		  true -> {'MIN',L--['MIN']}; % remove 'MIN' so it does not disturb
-		  false -> {hd(L),tl(L)}
-	      end,
-    Ub = case lists:member('MAX',L1) of
-	     true -> 'MAX';
-	     false -> lists:last(L1)
-	 end,
-    case SV of
-	[H] -> H;
-	_ -> SV
-    end,
-    %% for now we through away the Singlevalues so that they don't disturb
-    %% in the code generating phase (the effective Valuerange is already
-    %% calculated. If we want to keep the Singlevalues as well for
-    %% use in code gen phases we need to introduce a new representation
-    %% like {'ValueRange',{Lb,Ub},[ListOfRanges|AntiValues|Singlevalues]
-    %% These could be used to generate guards which allows only the specific
-    %% values , not the full range
-    [{'ValueRange',{Lb,Ub}}]. 
-
-		    
-%% get_constraints/2  
-%% Arguments are a list of constraints, which has the format {key,value},
-%% and a constraint type
-%% Returns a list of constraints only of the requested type or the atom
-%% 'no' if no such constraints were found
-get_constraints(L=[{CType,_}],CType) ->
-    L;
-get_constraints(C,CType) ->
-   keysearch_allwithkey(CType,1,C).
-
-%% keysearch_allwithkey(Key,Ix,L)
-%% Types:
-%% Key = is_atom()
-%% Ix = integer()
-%% L  = [TwoTuple]
-%% TwoTuple = [{atom(),term()}|...]
-%% Returns a List that contains all 
-%% elements from L that has a key Key as element Ix
-keysearch_allwithkey(Key,Ix,L) ->
-    lists:filter(fun(X) when is_tuple(X) ->
-			 case element(Ix,X) of
-			     Key -> true;
-			     _ -> false
-			 end;
-		    (_) -> false
-		 end, L).
-
-
-%% filter_extensions(C)
-%% takes a list of constraints as input and returns a list with the
-%% constraints and all extensions but the last are removed.
-filter_extensions([L]) when is_list(L) ->
-    [filter_extensions(L)];
-filter_extensions(C=[_H]) ->
-    C;
-filter_extensions(C) when is_list(C) ->
-    filter_extensions(C,[], []).
-
-filter_extensions([],Acc,[]) ->
-    Acc;
-filter_extensions([],Acc,[EC|ExtAcc]) ->
-    CwoExt = remove_extension(ExtAcc,[]),
-    CwoExt ++ [EC|Acc];
-filter_extensions([C={A,_E}|T],Acc,ExtAcc) when is_tuple(A) ->
-    filter_extensions(T,Acc,[C|ExtAcc]);
-filter_extensions([C={'SizeConstraint',{A,_B}}|T],Acc,ExtAcc) 
-  when is_list(A);is_tuple(A) ->
-    filter_extensions(T,Acc,[C|ExtAcc]);
-filter_extensions([C={'PermittedAlphabet',{{'SingleValue',_},E}}|T],Acc,ExtAcc)
-  when is_tuple(E); is_list(E) ->
-    filter_extensions(T,Acc,[C|ExtAcc]);
-filter_extensions([H|T],Acc,ExtAcc) ->
-    filter_extensions(T,[H|Acc],ExtAcc).
-
-remove_extension([],Acc) ->
-    Acc;
-remove_extension([{'SizeConstraint',{A,_B}}|R],Acc) ->
-    remove_extension(R,[{'SizeConstraint',A}|Acc]);
-remove_extension([{C,_E}|R],Acc) when is_tuple(C) ->
-    remove_extension(R,[C|Acc]);
-remove_extension([{'PermittedAlphabet',{A={'SingleValue',_},
-					E}}|R],Acc) 
-  when is_tuple(E);is_list(E) ->
-    remove_extension(R,[{'PermittedAlphabet',A}|Acc]).
-
-%% constraint_intersection(S,C) takes a list of constraints as input and
-%% performs intersections. Intersecions are performed when an 
-%% atom intersection is found between two constraints. 
-%% The list may be nested. Fix that later !!!
-constraint_intersection(_S,[]) ->
-    [];
-constraint_intersection(_S,C=[_E]) ->
-    C;
-constraint_intersection(S,C) when is_list(C) ->
-%    io:format("constraint_intersection: ~p~n",[C]),
-    case lists:member(intersection,C) of
-	true ->
-	    constraint_intersection1(S,C,[]);
-	_ ->
-	    C
+resolve_value1(S, HostType, #'Externalvaluereference'{value=Name}=ERef) ->
+    case resolve_namednumber(S, HostType, Name) of
+	V when is_integer(V) ->
+	    V;
+	not_named ->
+	    resolve_value1(S, HostType, get_referenced_value(S, ERef))
     end;
-constraint_intersection(_S,C) ->
-    [C].
-
-constraint_intersection1(S,[A,intersection,B|Rest],Acc) ->
-    AisecB = c_intersect(S,A,B),
-    constraint_intersection1(S, AisecB++Rest, Acc);
-constraint_intersection1(S,[A|Rest],Acc) ->
-    constraint_intersection1(S,Rest,[A|Acc]);
-constraint_intersection1(_, [], [C]) ->
-    C;
-constraint_intersection1(_,[],Acc) ->
-    lists:reverse(Acc).
-
-c_intersect(S,C1={'SingleValue',_},C2={'SingleValue',_}) ->
-    intersection_of_sv(S,[C1,C2]);
-c_intersect(S,C1={'ValueRange',_},C2={'ValueRange',_}) ->
-    intersection_of_vr(S,[C1,C2]);
-c_intersect(S,C1={'ValueRange',_},C2={'SingleValue',_}) ->
-    intersection_sv_vr(S,[C2],[C1]);
-c_intersect(S,C1={'SingleValue',_},C2={'ValueRange',_}) ->
-    intersection_sv_vr(S,[C1],[C2]);
-c_intersect(_S,C1,C2) ->
-    [C1,C2].
-
-%% combine_constraints(S,SV,VR,CComb)
-%% Types:
-%% S = is_record(state,S)
-%% SV = [] | [SVC]
-%% VR = [] | [VRC]
-%% CComb = [] | [Lists]
-%% SVC = {'SingleValue',integer()} | {'SingleValue',[integer(),...]}
-%% VRC = {'ValueRange',{Lb,Ub}}
-%% Lists = List of lists containing any constraint combination
-%% Lb = 'MIN' | integer()
-%% Ub = 'MAX' | integer()
-%% Returns a combination of the least common constraint among SV,VR and all
-%% elements in CComb
-combine_constraints(_S,[],VR,CComb) ->
-    VR ++ CComb;
-%    combine_combined_cnstr(S,VR,CComb);
-combine_constraints(_S,SV,[],CComb) ->
-    SV ++ CComb;
-%    combine_combined_cnstr(S,SV,CComb);
-combine_constraints(S,SV,VR,CComb) ->
-    C=intersection_sv_vr(S,SV,VR),
-    C ++ CComb.
-%    combine_combined_cnstr(S,C,CComb).
-
-intersection_sv_vr(_S,[C1={'SingleValue',SV}],[C2={'ValueRange',{_Lb,_Ub}}]) 
-  when is_integer(SV) ->
-    case is_int_in_vr(SV,C2) of
-	true -> [C1];
-	_ -> %%error({type,{"asn1 illegal constraint",C1,C2},S})
-	    %throw({error,{"asn1 illegal constraint",C1,C2}})
-	    %io:format("warning: could not analyze constraint ~p~n",[[C1,C2]]),
-	    [C1,C2]
+resolve_value1(S, HostType, {gt,V}) ->
+    case resolve_value1(S, HostType, V) of
+	Int when is_integer(Int) ->
+	    Int + 1;
+	_Other ->
+	    asn1_error(S, illegal_integer_value)
     end;
-intersection_sv_vr(_S,[C1={'SingleValue',SV}],[C2]) 
-  when is_list(SV) ->
-    case lists:filter(fun(X)->is_int_in_vr(X,C2) end,SV) of
-	[] ->
-	    %%error({type,{"asn1 illegal constraint",C1,C2},S});
-	    %throw({error,{"asn1 illegal constraint",C1,C2}});
-	    %io:format("warning: could not analyze constraint ~p~n",[[C1,C2]]),
-	    [C1,C2];
-	[V] -> [{'SingleValue',V}];
-	L -> [{'SingleValue',L}]
-    end.
-
-
-%% Size constraint [{'SizeConstraint',1},{'SizeConstraint',{{1,64},[]}}]
-
-intersection_of_size(_,[]) ->
-    [];
-intersection_of_size(_,C=[_SZ]) ->
-    C;
-intersection_of_size(S,[SZ,SZ|Rest]) ->
-    intersection_of_size(S,[SZ|Rest]);
-intersection_of_size(S,C=[C1={_,Int},{_,Range}|Rest]) 
-  when is_integer(Int),is_tuple(Range) ->
-    case Range of
-	{Lb,Ub} when Int >= Lb,
-		     Int =< Ub ->
-	    intersection_of_size(S,[C1|Rest]);
-	{{Lb,Ub},Ext} when is_list(Ext),Int >= Lb,Int =< Ub ->
-	    intersection_of_size(S,[C1|Rest]);
-	_ ->
-	    throw({error,{asn1,{illegal_size_constraint,C}}})
+resolve_value1(S, HostType, {lt,V}) ->
+    case resolve_value1(S, HostType, V) of
+	Int when is_integer(Int) ->
+	    Int - 1;
+	_Other ->
+	    asn1_error(S, illegal_integer_value)
     end;
-intersection_of_size(S,[C1={_,Range},C2={_,Int}|Rest]) 
-  when is_integer(Int),is_tuple(Range) ->
-    intersection_of_size(S,[C2,C1|Rest]);
-intersection_of_size(S,[{_,{Lb1,Ub1}},{_,{Lb2,Ub2}}|Rest]) ->
-    Lb=greatest_LB(ordsets:from_list([Lb1,Lb2])),
-    Ub=smallest_UB(ordsets:from_list([Ub1,Ub2])),
-    intersection_of_size(S,[{'SizeConstraint',{Lb,Ub}}|Rest]);
-intersection_of_size(_,SZ) ->
-    throw({error,{asn1,{illegal_size_constraint,SZ}}}).
-
-intersection_of_vr(_,[]) ->
-    [];
-intersection_of_vr(_,VR=[_C]) ->
-    VR;
-intersection_of_vr(S,[{_,{Lb1,Ub1}},{_,{Lb2,Ub2}}|Rest]) ->
-    Lb=greatest_LB(ordsets:from_list([Lb1,Lb2])),
-    Ub=smallest_UB(ordsets:from_list([Ub1,Ub2])),
-    intersection_of_vr(S,[{'ValueRange',{Lb,Ub}}|Rest]);
-intersection_of_vr(_S,VR) ->
-    %%error({type,{asn1,{illegal_value_range_constraint,VR}},S});
-    throw({error,{asn1,{illegal_value_range_constraint,VR}}}).
-
-intersection_of_sv(_,[]) ->
-    [];
-intersection_of_sv(_,SV=[_C]) ->
-    SV;
-intersection_of_sv(S,[SV,SV|Rest]) ->
-    intersection_of_sv(S,[SV|Rest]);
-intersection_of_sv(S,[{_,Int},{_,SV}|Rest]) when is_integer(Int),
-						 is_list(SV) ->
-    SV2=intersection_of_sv1(S,Int,SV),
-    intersection_of_sv(S,[SV2|Rest]);
-intersection_of_sv(S,[{_,SV},{_,Int}|Rest]) when is_integer(Int),
-						 is_list(SV) ->
-    SV2=intersection_of_sv1(S,Int,SV),
-    intersection_of_sv(S,[SV2|Rest]);
-intersection_of_sv(S,[{_,SV1},{_,SV2}|Rest]) when is_list(SV1),
-						  is_list(SV2) ->
-    SV3=common_set(SV1,SV2),
-    intersection_of_sv(S,[SV3|Rest]);
-intersection_of_sv(_S,SV) ->
-    %%error({type,{asn1,{illegal_single_value_constraint,SV}},S}).
-    throw({error,{asn1,{illegal_single_value_constraint,SV}}}).
-
-intersection_of_sv1(_S,Int,SV) when is_integer(Int),is_list(SV) ->
-    case lists:member(Int,SV) of
-	true -> {'SingleValue',Int};
+resolve_value1(S, _HostType, {'ValueFromObject',{object,Object},FieldName}) ->
+    get_value_from_object(S, Object, FieldName);
+resolve_value1(_, _, #valuedef{checked=true,value=V}) ->
+    V;
+resolve_value1(S, _, #valuedef{value={'ValueFromObject',
+				     {object,Object},FieldName}}) ->
+    get_value_from_object(S, Object, FieldName);
+resolve_value1(S, _HostType, #valuedef{}=VDef) ->
+    #valuedef{value=Val} = check_value(S,VDef),
+    Val;
+resolve_value1(_, _, V) ->
+    V.
+
+resolve_namednumber(S, #type{def=Def}, Name) ->
+    case Def of
+	{'ENUMERATED',NameList} ->
+	    resolve_namednumber_1(S, Name, NameList);
+	{'INTEGER',NameList} ->
+	    resolve_namednumber_1(S, Name, NameList);
 	_ ->
-	    %%error({type,{asn1,{illegal_single_value_constraint,Int,SV}},S})
-	    throw({error,{asn1,{illegal_single_value_constraint,Int,SV}}})
-    end;
-intersection_of_sv1(_S,SV1,SV2) ->
-    %%error({type,{asn1,{illegal_single_value_constraint,SV1,SV2}},S}).
-    throw({error,{asn1,{illegal_single_value_constraint,SV1,SV2}}}).
+	    not_named
+    end.
 
-greatest_LB([H]) ->
-    H;
-greatest_LB(L) ->
-    greatest_LB1(lists:reverse(L)).
-greatest_LB1(['MIN',H2|_T])->
-    H2;
-greatest_LB1([H|_T]) ->
-    H.
-smallest_UB(L) ->
-    hd(L).
-
-common_set(SV1,SV2) ->
-    lists:filter(fun(X)->lists:member(X,SV1) end,SV2).
-
-is_int_in_vr(Int,{_,{'MIN','MAX'}}) when is_integer(Int) ->
-    true;
-is_int_in_vr(Int,{_,{'MIN',Ub}}) when is_integer(Int),Int =< Ub ->
-    true;
-is_int_in_vr(Int,{_,{Lb,'MAX'}}) when is_integer(Int),Int >= Lb ->
-    true;
-is_int_in_vr(Int,{_,{Lb,Ub}}) when is_integer(Int),Int >= Lb,Int =< Ub ->
-    true;
-is_int_in_vr(_,_) ->
-    false.
-    
+resolve_namednumber_1(S, Name, NameList) ->
+    try
+	NamedNumberList = check_enumerated(S, NameList),
+	{_,N} = lookup_enum_value(S, Name, NamedNumberList),
+	N
+    catch _:_ ->
+	    not_named
+    end.
+
+%%%
+%%% End of constraint handling.
+%%%
 
 check_imported(S,Imodule,Name) ->
     check_imported(S,Imodule,Name,false).
@@ -4628,55 +3760,53 @@ check_reference(S,#'Externaltypereference'{pos=Pos,module=Emod,type=Name}) ->
 	    #'Externaltypereference'{pos=Pos,module=ModName,type=Name}
     end.
 
+get_referenced_value(S, T) ->
+    case get_referenced_type(S, T) of
+	{ExtMod,#valuedef{value=#'Externalvaluereference'{}=Ref}} ->
+	    get_referenced_value(update_state(S, ExtMod), Ref);
+	{_,#valuedef{value=Val}} ->
+	    Val
+    end.
 
-get_referenced_type(S,Ext) when is_record(Ext,'Externaltypereference') ->
-    case match_parameters(S,Ext, S#state.parameters) of
-	Ext -> 
-	    #'Externaltypereference'{pos=Pos,module=Emod,type=Etype} = Ext,
-	    case S#state.mname of
-		Emod -> % a local reference in this module
-		    get_referenced1(S,Emod,Etype,Pos);
-		_ ->% always when multi file compiling
-		    case lists:member(Emod,S#state.inputmodules) of
-			true ->
-			    get_referenced1(S,Emod,Etype,Pos);
-			false ->
-			    get_referenced(S,Emod,Etype,Pos)
-		    end
-	    end;
-	ERef = #'Externaltypereference'{} ->
-	    get_referenced_type(S,ERef);
-	Other ->
-	    {undefined,Other}
-    end;
-get_referenced_type(S=#state{mname=Emod},
-		    ERef=#'Externalvaluereference'{pos=P,module=Emod,
-						   value=Eval}) ->
-    case match_parameters(S,ERef,S#state.parameters) of
-	ERef ->
-	    get_referenced1(S,Emod,Eval,P);
-	OtherERef when is_record(OtherERef,'Externalvaluereference') ->
-	    get_referenced_type(S,OtherERef);
-	Value ->
-	    {Emod,Value}
-    end;
-get_referenced_type(S,ERef=#'Externalvaluereference'{pos=Pos,module=Emod,
-						value=Eval}) ->
-    case match_parameters(S,ERef,S#state.parameters) of
-	ERef ->
-	    case lists:member(Emod,S#state.inputmodules) of
-		true ->
-		    get_referenced1(S,Emod,Eval,Pos);
-		false ->
-		    get_referenced(S,Emod,Eval,Pos)
-	    end;
-	OtherERef  ->
-	    get_referenced_type(S,OtherERef)
-    end;
-get_referenced_type(S,#identifier{val=Name,pos=Pos}) ->
-    get_referenced1(S,undefined,Name,Pos);
-get_referenced_type(_S,Type) ->
-    {undefined,Type}.
+get_referenced_type(S, T) ->
+    get_referenced_type(S, T, false).
+
+get_referenced_type(S, T, Recurse) ->
+    case do_get_referenced_type(S, T) of
+	{_,#typedef{typespec=#type{def=#'Externaltypereference'{}=ERef}}}
+	  when Recurse ->
+	    get_referenced_type(S, ERef, Recurse);
+	{_,_}=Res ->
+	    Res
+    end.
+
+do_get_referenced_type(S, T0) ->
+    case match_parameter(S, T0) of
+	T0 ->
+	    do_get_ref_type_1(S, T0);
+	T ->
+	    do_get_referenced_type(S, T)
+    end.
+
+do_get_ref_type_1(S, #'Externaltypereference'{pos=P,
+					      module=M,
+					      type=T}) ->
+    do_get_ref_type_2(S, P, M, T);
+do_get_ref_type_1(S, #'Externalvaluereference'{pos=P,
+					       module=M,
+					       value=V}) ->
+    do_get_ref_type_2(S, P, M, V);
+do_get_ref_type_1(_, T) ->
+    {undefined,T}.
+
+do_get_ref_type_2(#state{mname=Current,inputmodules=Modules}=S,
+		  Pos, M, T) ->
+    case M =:= Current orelse lists:member(M, Modules) of
+	true ->
+	    get_referenced1(S, M, T, Pos);
+	false ->
+	    get_referenced(S, M, T, Pos)
+    end.
 
 %% get_referenced/3
 %% The referenced entity Ename may in case of an imported parameterized
@@ -4693,7 +3823,7 @@ get_referenced(S,Emod,Ename,Pos) ->
 	    %% May be an imported entity in module Emod or Emod may not exist
 	    case asn1_db:dbget(Emod,'MODULE') of
 		undefined ->
-		    throw({error,{asn1,{module_not_found,Emod}}});
+		    asn1_error(S, {undefined_import, Ename, Emod});
 		_ ->
 		    NewS = update_state(S,Emod),
 		    get_imported(NewS,Ename,Emod,Pos)
@@ -4723,12 +3853,11 @@ get_imported(S,Name,Module,Pos) ->
 	    parse_and_save(S,Imodule),
 	    case asn1_db:dbget(Imodule,'MODULE') of
 		undefined ->
-		    throw({error,{asn1,{module_not_found,Imodule}}});
+		    asn1_error(S, {undefined_import, Name, Module});
 		Im when is_record(Im,module) ->
 		    case is_exported(Im,Name) of
 			false ->
-			    throw({error,
-				   {asn1,{not_exported,{Im,Name}}}});
+			    asn1_error(S, {undefined_export, Name});
 			_ ->
 			    ?dbg("get_imported, is_exported ~p, ~p~n",[Imodule,Name]),
 			    get_referenced_type(S,
@@ -4741,37 +3870,6 @@ get_imported(S,Name,Module,Pos) ->
 	    get_renamed_reference(S,Name,Module)
     end.
 
-check_and_save(S,#'Externaltypereference'{module=M}=ERef,#typedef{checked=false}=TDef,Settings)
-  when S#state.mname /= M ->
-    %% This ERef is an imported type (or maybe a set.asn compilation)
-    NewS = S#state{mname=M,module=load_asn1_module(S,M),
-		   type=TDef,tname=get_datastr_name(TDef)},
-    Type=check_type(NewS,TDef,TDef#typedef.typespec),%XXX
-    CheckedTDef = TDef#typedef{checked=true,
-			       typespec=Type},
-    asn1_db:dbput(M,get_datastr_name(TDef),CheckedTDef),
-    {merged_name(S,ERef),Settings};
-check_and_save(S,#'Externaltypereference'{module=M,type=N}=Eref,
-	       #ptypedef{name=Name,args=Params} = PTDef,Settings) ->
-    %% instantiate a parameterized type
-    %% The parameterized type should be saved as a type in the module
-    %% it was instantiated.
-    NewS = S#state{mname=M,module=load_asn1_module(S,M),
-		   type=PTDef,tname=Name},
-    {Args,RestSettings} = lists:split(length(Params),Settings),
-    Type = check_type(NewS,PTDef,#type{def={pt,Eref,Args}}),
-    ERefName = new_reference_name(N),
-    ERefNew = #'Externaltypereference'{type=ERefName,module=S#state.mname},
-    NewTDef=#typedef{checked=true,name=ERefName,
-		     typespec=Type},
-    insert_once(S,parameterized_objects,{ERefName,type,NewTDef}),
-    asn1_db:dbput(S#state.mname,ERefNew#'Externaltypereference'.type,
-		  NewTDef),
-    {ERefNew,RestSettings};
-check_and_save(_S,ERef,TDef,Settings) ->
-    %% This might be a renamed type in a set of specs, so rename the ERef
-    {ERef#'Externaltypereference'{type=asn1ct:get_name_of_def(TDef)},Settings}.
-
 save_object_set_instance(S,Name,ObjSetSpec) 
   when is_record(ObjSetSpec,'ObjectSet') ->
     NewObjSet = #typedef{checked=true,name=Name,typespec=ObjSetSpec},
@@ -4838,18 +3936,14 @@ update_state(S,ModuleName) ->
 	    S;
 	_ ->
 	    parse_and_save(S,ModuleName),
-	    case asn1_db:dbget(ModuleName,'MODULE') of
-		RefedMod when is_record(RefedMod,module) ->
-		    S#state{mname=ModuleName,module=RefedMod};
-		_ -> throw({error,{asn1,{module_does_not_exist,ModuleName}}})
-	    end
+	    Mod = #module{} = asn1_db:dbget(ModuleName,'MODULE'),
+	    S#state{mname=ModuleName,module=Mod}
     end.
 
-
 get_renamed_reference(S,Name,Module) ->
     case renamed_reference(S,Name,Module) of
 	undefined ->
-	    throw({error,{asn1,{undefined_type,Name}}});
+	    asn1_error(S, {undefined, Name});
 	NewTypeName when NewTypeName =/= Name ->
 	    get_referenced1(S,Module,NewTypeName,undefined)
     end.
@@ -4900,37 +3994,49 @@ get_importmoduleoftype([I|Is],Name) ->
 get_importmoduleoftype([],_) ->
     undefined.
 		     
+match_parameters(S, Names) ->
+    [match_parameter(S, Name) || Name <- Names].
 
-match_parameters(_S,Name,[]) ->
-    Name;
+match_parameter(#state{parameters=Ps}=S, Name) ->
+    match_parameter(S, Name, Ps).
 
-match_parameters(_S,#'Externaltypereference'{type=Name},[{#'Externaltypereference'{type=Name},NewName}|_T]) ->
+match_parameter(_S, Name, []) ->
+    Name;
+match_parameter(S, {valueset,{element_set,#type{}=Ts,none}}, Ps) ->
+    match_parameter(S, {valueset,Ts}, Ps);
+match_parameter(_S, #'Externaltypereference'{type=Name},
+		[{#'Externaltypereference'{type=Name},NewName}|_T]) ->
     NewName;
-match_parameters(_S,#'Externaltypereference'{type=Name},[{{_,#'Externaltypereference'{type=Name}},NewName}|_T]) ->
+match_parameter(_S, #'Externaltypereference'{type=Name},
+		[{{_,#'Externaltypereference'{type=Name}},NewName}|_T]) ->
     NewName;
-match_parameters(_S,#'Externalvaluereference'{value=Name},[{#'Externalvaluereference'{value=Name},NewName}|_T]) ->
+match_parameter(_S, #'Externalvaluereference'{value=Name},
+		[{#'Externalvaluereference'{value=Name},NewName}|_T]) ->
     NewName;
-match_parameters(_S,#'Externalvaluereference'{value=Name},[{{_,#'Externalvaluereference'{value=Name}},NewName}|_T]) ->
+match_parameter(_S, #'Externalvaluereference'{value=Name},
+		[{{_,#'Externalvaluereference'{value=Name}},NewName}|_T]) ->
     NewName;
-match_parameters(_S,#type{def=#'Externaltypereference'{module=M,type=Name}},
-		 [{#'Externaltypereference'{module=M,type=Name},Type}]) ->
+match_parameter(_S, #type{def=#'Externaltypereference'{module=M,type=Name}},
+		[{#'Externaltypereference'{module=M,type=Name},Type}]) ->
     Type;
-match_parameters(_S,{valueset,#type{def=#'Externaltypereference'{type=Name}}},
-		 [{{_,#'Externaltypereference'{type=Name}},{valueset,#type{def=NewName}}}|_T]) ->
+match_parameter(_S, {valueset,#type{def=#'Externaltypereference'{type=Name}}},
+		[{{_,#'Externaltypereference'{type=Name}},
+		  {valueset,#type{def=NewName}}}|_T]) ->
     NewName;
-match_parameters(_S,{valueset,#type{def=#'Externaltypereference'{type=Name}}},
-		 [{{_,#'Externaltypereference'{type=Name}},
-		   NewName=#type{def=#'Externaltypereference'{}}}|_T]) ->
+match_parameter(_S, {valueset,#type{def=#'Externaltypereference'{type=Name}}},
+		[{{_,#'Externaltypereference'{type=Name}},
+		  NewName=#type{def=#'Externaltypereference'{}}}|_T]) ->
     NewName#type.def;
-match_parameters(_S,{valueset,#type{def=#'Externaltypereference'{type=Name}}},
-		 [{{_,#'Externaltypereference'{type=Name}},NewName}|_T]) ->
+match_parameter(_S, {valueset,#type{def=#'Externaltypereference'{type=Name}}},
+		[{{_,#'Externaltypereference'{type=Name}},NewName}|_T]) ->
     NewName;
 %% When a parameter is a parameterized element it has to be
 %% instantiated now!
-match_parameters(S,{valueset,T=#type{def={pt,_,_Args}}},_Parameters) ->
-    case catch check_type(S,#typedef{name=S#state.tname,typespec=T},T) of
-	pobjectsetdef ->
-
+match_parameter(S, {valueset,T=#type{def={pt,_,_Args}}}, _Ps) ->
+    try check_type(S,#typedef{name=S#state.tname,typespec=T},T) of
+	#type{def=Ts} ->
+	    Ts
+    catch pobjectsetdef ->
  	    {_,ObjRef,_Params} = T#type.def,
  	    {_,ObjDef}=get_referenced_type(S,ObjRef),
 	    %%ObjDef is a pvaluesetdef where the type field holds the class
@@ -4948,17 +4054,15 @@ match_parameters(S,{valueset,T=#type{def={pt,_,_Args}}},_Parameters) ->
 	    ObjectSet = #'ObjectSet'{class=RightClassRef,set=T},
  	    ObjSpec = check_object(S,#typedef{typespec=ObjectSet},ObjectSet),
 	    Name = list_to_atom(asn1ct_gen:list2name([get_datastr_name(ObjDef)|S#state.recordtopname])),	 
-	    save_object_set_instance(S,Name,ObjSpec);
-	pvaluesetdef -> error({pvaluesetdef,"parameterized valueset",S});
-	{error,_Reason} -> error({type,"error in parameter",S});
-	Ts when is_record(Ts,type) -> Ts#type.def
+	    save_object_set_instance(S,Name,ObjSpec)
     end;
+
 %% same as previous, only depends on order of parsing
-match_parameters(S,{valueset,{pos,{objectset,_,POSref},Args}},Parameters) ->
-    match_parameters(S,{valueset,#type{def={pt,POSref,Args}}},Parameters);
-match_parameters(S,Name, [_H|T]) ->
-    %%io:format("match_parameters(~p,~p)~n",[Name,[H|T]]),
-    match_parameters(S,Name,T).
+match_parameter(S, {valueset,{pos,{objectset,_,POSref},Args}}, Ps) ->
+    match_parameter(S, {valueset,#type{def={pt,POSref,Args}}}, Ps);
+match_parameter(S, Name, [_H|T]) ->
+    %%io:format("match_parameter(~p,~p)~n",[Name,[H|T]]),
+    match_parameter(S, Name, T).
 
 imported(S,Name) ->
     {imports,Ilist} = (S#state.module)#module.imports,
@@ -4975,73 +4079,45 @@ imported1(Name,
     end;
 imported1(_Name,[]) ->
     false.
-	
 
-check_integer(_S,[],_C) ->
+%% Check the named number list for an INTEGER or a BIT STRING.
+check_named_number_list(_S, []) ->
     [];
-check_integer(S,NamedNumberList,_C) ->
-    case [X || X <- NamedNumberList, tuple_size(X) =:= 2] of
-	NamedNumberList ->
-	    %% An already checked integer with NamedNumberList
-	    NamedNumberList;
-	_ ->
-	    case check_unique(NamedNumberList,2) of
-		[] -> 
-		    check_int(S,NamedNumberList,[]);
-		L when is_list(L) ->
-		    error({type,{duplicates,L},S}),
-		    unchanged
-	    end
+check_named_number_list(_S, [{_,_}|_]=NNL) ->
+    %% The named number list has already been checked.
+    NNL;
+check_named_number_list(S, NNL0) ->
+    %% Check that the names are unique.
+    case check_unique(NNL0, 2) of
+	[] ->
+	    NNL1 = [{Id,resolve_valueref(S, Val)} || {'NamedNumber',Id,Val} <- NNL0],
+	    NNL = lists:keysort(2, NNL1),
+	    case check_unique(NNL, 2) of
+		[] ->
+		    NNL;
+		[Val|_] ->
+		    asn1_error(S, {value_reused,Val})
+	    end;
+	[H|_] ->
+	    asn1_error(S, {namelist_redefinition,H})
     end.
 
-    
-check_int(S,[{'NamedNumber',Id,Num}|T],Acc) when is_integer(Num) ->
-    check_int(S,T,[{Id,Num}|Acc]);
-check_int(S,[{'NamedNumber',Id,{identifier,_,Name}}|T],Acc) ->
-    Val = dbget_ex(S,S#state.mname,Name),
-    check_int(S,[{'NamedNumber',Id,Val#valuedef.value}|T],Acc);
-check_int(S,[{'NamedNumber',Id,{'Externalvaluereference',_,Mod,Name}}|T],Acc) ->
-    Val = dbget_ex(S,Mod,Name),
-    check_int(S,[{'NamedNumber',Id,Val#valuedef.value}|T],Acc);
-check_int(_S,[],Acc) ->
-    lists:keysort(2,Acc).
+resolve_valueref(S, #'Externalvaluereference'{} = T) ->
+    get_referenced_value(S, T);
+resolve_valueref(_, Val) when is_integer(Val) ->
+    Val.
 
-check_real(_S,_Constr) ->
-    ok.
+check_integer(S, NNL) ->
+    check_named_number_list(S, NNL).
 
-check_bitstring(_S,[],_Constr) ->
-    [];
-check_bitstring(S,NamedNumberList,_Constr) ->
-    case check_unique(NamedNumberList,2) of
-	[] ->
-	    check_bitstr(S,NamedNumberList,[]);
-	L when is_list(L) ->
-	    error({type,{duplicates,L},S}),
-	    unchanged
-    end.
+check_bitstring(S, NNL0) ->
+    NNL = check_named_number_list(S, NNL0),
+    _ = [asn1_error(S, {invalid_bit_number,Bit}) ||
+	    {_,Bit} <- NNL, Bit < 0],
+    NNL.
 
-check_bitstr(S,[{'NamedNumber',Id,Num}|T],Acc)when is_integer(Num) ->
-    check_bitstr(S,T,[{Id,Num}|Acc]);
-check_bitstr(S,[{'NamedNumber',Id,Name}|T],Acc) when is_atom(Name) ->
-%%check_bitstr(S,[{'NamedNumber',Id,{identifier,_,Name}}|T],Acc) -> 
-%%    io:format("asn1ct_check:check_bitstr/3 hej hop ~w~n",[Name]),
-    Val = dbget_ex(S,S#state.mname,Name),
-%%    io:format("asn1ct_check:check_bitstr/3: ~w~n",[Val]),
-    check_bitstr(S,[{'NamedNumber',Id,Val#valuedef.value}|T],Acc);
-check_bitstr(S,[],Acc) ->
-    case check_unique(Acc,2) of
-	[] ->
-	    lists:keysort(2,Acc);
-	L when is_list(L) ->
-	    error({type,{duplicate_values,L},S}),
-	    unchanged
-    end;
-%% When a BIT STRING already is checked, for instance a COMPONENTS OF S
-%% where S is a sequence that has a component that is a checked BS, the
-%% NamedNumber list is a list of {atom(),integer()} elements.
-check_bitstr(S,[El={Id,Num}|Rest],Acc) when is_atom(Id),is_integer(Num) ->
-    check_bitstr(S,Rest,[El|Acc]).
-    
+check_real(_S,_Constr) ->
+    ok.
     
 %% Check INSTANCE OF
 %% check that DefinedObjectClass is of TYPE-IDENTIFIER class
@@ -5052,20 +4128,16 @@ check_instance_of(S,DefinedObjectClass,Constraint) ->
     check_type_identifier(S,DefinedObjectClass),
     iof_associated_type(S,Constraint).
     
-
-check_type_identifier(_S,'TYPE-IDENTIFIER') ->
-    ok;
-check_type_identifier(S,Eref=#'Externaltypereference'{}) ->
-    case get_referenced_type(S,Eref) of
-	{_,#classdef{name='TYPE-IDENTIFIER'}} -> ok;
-	{_,#classdef{typespec=NextEref}} 
-	when is_record(NextEref,'Externaltypereference') ->
-	    check_type_identifier(S,NextEref);
+check_type_identifier(S, Eref=#'Externaltypereference'{type=Class}) ->
+    case get_referenced_type(S, Eref) of
+	{_,#classdef{name='TYPE-IDENTIFIER'}} ->
+	    ok;
+	{_,#classdef{typespec=#'Externaltypereference'{}=NextEref}} ->
+	    check_type_identifier(S, NextEref);
 	{_,TD=#typedef{typespec=#type{def=#'Externaltypereference'{}}}} ->
-	    check_type_identifier(S,(TD#typedef.typespec)#type.def);
-	Err ->
-	    error({type,{"object set in type INSTANCE OF "
-			 "not of class TYPE-IDENTIFIER",Eref,Err},S})
+	    check_type_identifier(S, (TD#typedef.typespec)#type.def);
+	_ ->
+	    asn1_error(S, {illegal_instance_of,Class})
     end.
 
 iof_associated_type(S,[]) ->
@@ -5074,12 +4146,7 @@ iof_associated_type(S,[]) ->
     case get(instance_of) of
 	undefined ->
 	    AssociateSeq = iof_associated_type1(S,[]),
-	    Tag =
-		case S#state.erule of
-		    ber ->
-			[?TAG_CONSTRUCTED(?N_INSTANCE_OF)];
-		    _ -> []
-		end,
+	    Tag = [?TAG_CONSTRUCTED(?N_INSTANCE_OF)],
 	    TypeDef=#typedef{checked=true,
 			     name='INSTANCE OF',
 			     typespec=#type{tag=Tag,
@@ -5105,16 +4172,11 @@ iof_associated_type1(S,C) ->
 	    [] -> 'ASN1_OPEN_TYPE';
 	    _ -> {typefield,'Type'}
 	end,
-    {ObjIdTag,C1TypeTag}=
-	case S#state.erule of
-	    ber ->
-		{[{'UNIVERSAL',8}],
-		 [#tag{class='UNIVERSAL',
-		       number=6,
-		       type='IMPLICIT',
-		       form=0}]};
-	    _ -> {[{'UNIVERSAL','INTEGER'}],[]}
-	end,
+    ObjIdTag = [{'UNIVERSAL',8}],
+    C1TypeTag = [#tag{class='UNIVERSAL',
+		      number=6,
+		      type='IMPLICIT',
+		      form=0}],
     TypeIdentifierRef=#'Externaltypereference'{module=ModuleName,
 					       type='TYPE-IDENTIFIER'},
     ObjectIdentifier =
@@ -5153,9 +4215,13 @@ iof_associated_type1(S,C) ->
 
 %% returns the leading attribute, the constraint of the components and
 %% the tablecinf value for the second component.
-instance_of_constraints(_,[]) ->
+instance_of_constraints(_, []) ->
     {false,[],[],[]};
-instance_of_constraints(S, [{simpletable,Type}]) ->
+instance_of_constraints(S, [{element_set,{simpletable,C},none}]) ->
+    {element_set,Type,none} = C,
+    instance_of_constraints_1(S, Type).
+
+instance_of_constraints_1(S, Type) ->
     #type{def=#'Externaltypereference'{type=Name}} = Type,
     ModuleName = S#state.mname,
     ObjectSetRef=#'Externaltypereference'{module=ModuleName,
@@ -5175,96 +4241,100 @@ instance_of_constraints(S, [{simpletable,Type}]) ->
 				     valueindex=[]},
     {TableCInf,[{simpletable,Name}],CRel,[{objfun,ObjectSetRef}]}.
 
-%% Check ENUMERATED
-%% ****************************************
-%% Check that all values are unique
-%% assign values to un-numbered identifiers
-%% check that the constraints are allowed and correct
-%% put the updated info back into database
-check_enumerated(_S,[{Name,Number}|_Rest]= NNList,_Constr) when is_atom(Name), is_integer(Number)->
-    %% already checked , just return the same list
-    NNList;
-check_enumerated(_S,{[{Name,Number}|_Rest],L}= NNList,_Constr) when is_atom(Name), is_integer(Number), is_list(L)->
-    %% already checked , contains extension marker, just return the same lists
-    NNList;
-check_enumerated(S,NamedNumberList,_Constr) ->
-    check_enum(S,NamedNumberList,[],[],[]).
-
-%% identifiers are put in Acc2
-%% returns either [{Name,Number}] or {[{Name,Number}],[{ExtName,ExtNumber}]}
-%% the latter is returned if the ENUMERATION contains EXTENSIONMARK
-check_enum(S,[{'NamedNumber',Id,Num}|T],Acc1,Acc2,Root) when is_integer(Num) ->
-    check_enum(S,T,[{Id,Num}|Acc1],Acc2,Root);
-check_enum(S,[{'NamedNumber',Id,{identifier,_,Name}}|T],Acc1,Acc2,Root) ->
-    Val = dbget_ex(S,S#state.mname,Name),
-    check_enum(S,[{'NamedNumber',Id,Val#valuedef.value}|T],Acc1,Acc2,Root);
-check_enum(S,['EXTENSIONMARK'|T],Acc1,Acc2,_Root) ->
-    NewAcc2 = lists:keysort(2,Acc1),
-    NewList = enum_number(lists:reverse(Acc2),NewAcc2,0,[],[]),
-    { NewList, check_enum(S,T,[],[],enum_counts(NewList))};
-check_enum(S,[Id|T],Acc1,Acc2,Root) when is_atom(Id) ->
-    check_enum(S,T,Acc1,[Id|Acc2],Root);
-check_enum(_S,[],Acc1,Acc2,Root) ->
-    NewAcc2 = lists:keysort(2,Acc1),
-    enum_number(lists:reverse(Acc2),NewAcc2,0,[],Root).
-
-
-% assign numbers to identifiers , numbers from 0 ... but must not
-% be the same as already assigned to NamedNumbers
-enum_number(Identifiers,NamedNumbers,Cnt,Acc,[]) ->
-    enum_number(Identifiers,NamedNumbers,Cnt,Acc);
-enum_number(Identifiers,NamedNumbers,_Cnt,Acc,CountL) ->
-    enum_extnumber(Identifiers,NamedNumbers,Acc,CountL).
-
-enum_number([H|T],[{Id,Num}|T2],Cnt,Acc) when Num > Cnt ->
-    enum_number(T,[{Id,Num}|T2],Cnt+1,[{H,Cnt}|Acc]);
-enum_number([H|T],[{Id,Num}|T2],Cnt,Acc) when Num < Cnt -> % negative Num
-    enum_number(T,T2,Cnt+1,[{H,Cnt},{Id,Num}|Acc]);
-enum_number([],L2,_Cnt,Acc) ->
-    lists:append([lists:reverse(Acc),L2]);
-enum_number(L,[{Id,Num}|T2],Cnt,Acc) -> % Num == Cnt
-    enum_number(L,T2,Cnt+1,[{Id,Num}|Acc]);
-enum_number([H|T],[],Cnt,Acc) ->
-    enum_number(T,[],Cnt+1,[{H,Cnt}|Acc]).
-    
-enum_extnumber(Identifiers,NamedNumbers,Acc,[C]) ->
-    check_add_enum_numbers(NamedNumbers,[C]),
-    enum_number(Identifiers,NamedNumbers,C,Acc);
-enum_extnumber([H|T],[{Id,Num}|T2],Acc,[C|Counts]) when Num > C ->
-    enum_extnumber(T,[{Id,Num}|T2],[{H,C}|Acc],Counts);
-enum_extnumber([],L2,Acc,Cnt) ->
-    check_add_enum_numbers(L2, Cnt),
-    lists:concat([lists:reverse(Acc),L2]);
-enum_extnumber(_Identifiers,[{Id,Num}|_T2],_Acc,[C|_]) when Num < C ->
-%%    enum_extnumber(Identifiers,T2,[{Id,Num}|Acc],Counts);
-    exit({error,{asn1,"AdditionalEnumeration element with same number as root element",{Id,Num}}});
-enum_extnumber(Identifiers,[{Id,Num}|T2],Acc,[_C|Counts]) -> % Num =:= C
-    enum_extnumber(Identifiers,T2,[{Id,Num}|Acc],Counts);
-enum_extnumber([H|T],[],Acc,[C|Counts]) ->
-    enum_extnumber(T,[],[{H,C}|Acc],Counts).
-
-enum_counts([]) ->
-    [0];
-enum_counts(L) ->
-    Used=[I||{_,I}<-L],
-    AddEnumLb = lists:max(Used) + 1,
-    lists:foldl(fun(El,AccIn)->lists:delete(El,AccIn) end, 
-		lists:seq(0,AddEnumLb),
-		Used).
-check_add_enum_numbers(L, Cnt) ->
-    Max = lists:max(Cnt),
-    Fun = fun({_,N}=El) when N < Max ->
-		  case lists:member(N,Cnt) of
-		      false ->
-			  exit({error,{asn1,"AdditionalEnumeration element with same number as root element",El}});
-		      _ ->
-			  ok
-		  end;
-	     (_) ->
-		  ok
-	  end,
-    lists:foreach(Fun,L).
+%%%
+%%% Check ENUMERATED.
+%%%
+
+check_enumerated(_S, [{Name,Number}|_]=NNL)
+  when is_atom(Name), is_integer(Number) ->
+    %% Already checked.
+    NNL;
+check_enumerated(_S, {[{Name,Number}|_],L}=NNL)
+  when is_atom(Name), is_integer(Number), is_list(L) ->
+    %% Already checked (with extension).
+    NNL;
+check_enumerated(S, NNL) ->
+    check_enum_ids(S, NNL, gb_sets:empty()),
+    check_enum(S, NNL, gb_sets:empty(), []).
+
+check_enum_ids(S, [{'NamedNumber',Id,_}|T], Ids0) ->
+    Ids = check_enum_update_ids(S, Id, Ids0),
+    check_enum_ids(S, T, Ids);
+check_enum_ids(S, ['EXTENSIONMARK'|T], Ids) ->
+    check_enum_ids(S, T, Ids);
+check_enum_ids(S, [Id|T], Ids0) when is_atom(Id) ->
+    Ids = check_enum_update_ids(S, Id, Ids0),
+    check_enum_ids(S, T, Ids);
+check_enum_ids(_, [], _) ->
+    ok.
 
+check_enum(S, [{'NamedNumber',Id,N}|T], Used0, Acc) ->
+    Used = check_enum_update_used(S, Id, N, Used0),
+    check_enum(S, T, Used, [{Id,N}|Acc]);
+check_enum(S, ['EXTENSIONMARK'|Ext0], Used0, Acc0) ->
+    Acc = lists:reverse(Acc0),
+    {Root,Used,Cnt} = check_enum_number_root(Acc, Used0, 0, []),
+    Ext = check_enum_ext(S, Ext0, Used, Cnt, []),
+    {Root,Ext};
+check_enum(S, [Id|T], Used, Acc) when is_atom(Id) ->
+    check_enum(S, T, Used, [Id|Acc]);
+check_enum(_, [], Used, Acc0) ->
+    Acc = lists:reverse(Acc0),
+    {Root,_,_} = check_enum_number_root(Acc, Used, 0, []),
+    lists:keysort(2, Root).
+
+check_enum_number_root([Id|T]=T0, Used0, Cnt, Acc) when is_atom(Id) ->
+    case gb_sets:is_element(Cnt, Used0) of
+	false ->
+	    Used = gb_sets:insert(Cnt, Used0),
+	    check_enum_number_root(T, Used, Cnt+1, [{Id,Cnt}|Acc]);
+	true ->
+	    check_enum_number_root(T0, Used0, Cnt+1, Acc)
+    end;
+check_enum_number_root([H|T], Used, Cnt, Acc) ->
+    check_enum_number_root(T, Used, Cnt, [H|Acc]);
+check_enum_number_root([], Used, Cnt, Acc) ->
+    {lists:keysort(2, Acc),Used,Cnt}.
+
+check_enum_ext(S, [{'NamedNumber',Id,N}|T], Used0, C, Acc) ->
+    Used = check_enum_update_used(S, Id, N, Used0),
+    if
+	N < C ->
+	    asn1_error(S, {enum_not_ascending,Id,N,C-1});
+	true ->
+	    ok
+    end,
+    check_enum_ext(S, T, Used, N+1, [{Id,N}|Acc]);
+check_enum_ext(S, [Id|T]=T0, Used0, C, Acc) when is_atom(Id) ->
+    case gb_sets:is_element(C, Used0) of
+	true ->
+	    check_enum_ext(S, T0, Used0, C+1, Acc);
+	false ->
+	    Used = gb_sets:insert(C, Used0),
+	    check_enum_ext(S, T, Used, C+1, [{Id,C}|Acc])
+    end;
+check_enum_ext(_, [], _, _, Acc) ->
+    lists:keysort(2, Acc).
+
+check_enum_update_ids(S, Id, Ids) ->
+    case gb_sets:is_element(Id, Ids) of
+	false ->
+	    gb_sets:insert(Id, Ids);
+	true ->
+	    asn1_error(S, {enum_illegal_redefinition,Id})
+    end.
+
+check_enum_update_used(S, Id, N, Used) ->
+    case gb_sets:is_element(N, Used) of
+	false ->
+	    gb_sets:insert(N, Used);
+	true ->
+	    asn1_error(S, {enum_reused_value,Id,N})
+    end.
+
+%%%
+%%% End of ENUMERATED checking.
+%%%
 
 check_boolean(_S,_Constr) ->
     ok.
@@ -5309,7 +4379,7 @@ check_sequence(S,Type,Comps)  ->
 	    CompListTuple = complist_as_tuple(NewComps4),
 	    {CRelInf,CompListTuple};
 	Dupl ->
-	    throw({error,{asn1,{duplicate_components,Dupl}}})
+	    asn1_error(S, {duplicate_identifier, error_value(hd(Dupl))})
     end.
 
 complist_as_tuple(CompList) ->
@@ -5319,8 +4389,6 @@ complist_as_tuple([#'EXTENSIONMARK'{}|T], Acc, Ext, Acc2, root) ->
     complist_as_tuple(T, Acc, Ext, Acc2, ext);
 complist_as_tuple([#'EXTENSIONMARK'{}|T], Acc, Ext, Acc2, ext) ->
     complist_as_tuple(T, Acc, Ext, Acc2, root2);
-complist_as_tuple([#'EXTENSIONMARK'{}|_T], _Acc, _Ext, _Acc2, root2) ->
-    throw({error,{asn1,{too_many_extension_marks}}});
 complist_as_tuple([C|T], Acc, Ext, Acc2, root) ->
     complist_as_tuple(T, [C|Acc], Ext, Acc2, root);
 complist_as_tuple([C|T], Acc, Ext, Acc2, ext) ->
@@ -5363,11 +4431,11 @@ expand_components2(S,{_,PT={pt,_,_}}) ->
 expand_components2(S,{_,OCFT = #'ObjectClassFieldType'{}}) ->
     UncheckedType = #type{def=OCFT},
     Type = check_type(S,#typedef{typespec=UncheckedType},UncheckedType),
-    expand_components2(S,{undefined,oCFT_def(S,Type)});
+    expand_components2(S, {undefined,ocft_def(Type)});
 expand_components2(S,{_,ERef}) when is_record(ERef,'Externaltypereference') ->
     expand_components2(S,get_referenced_type(S,ERef));
-expand_components2(_S,Err) ->
-    throw({error,{asn1,{illegal_COMPONENTS_OF,Err}}}).
+expand_components2(S,{_, What}) ->
+    asn1_error(S, {illegal_COMPONENTS_OF, error_value(What)}).
 
 take_only_rootset([])->
     [];
@@ -5416,7 +4484,7 @@ check_sequenceof(S,Type,Component) when is_record(Component,type) ->
 
 check_set(S,Type,Components) ->
     {TableCInf,NewComponents} = check_sequence(S,Type,Components),
-    check_distinct_tags(NewComponents,[]),
+    check_unique_tags(S, collect_components(NewComponents), []),
     case {lists:member(der,S#state.options),S#state.erule} of
 	{true,_} ->
 	    {Sorted,SortedComponents} = sort_components(der,S,NewComponents),
@@ -5428,35 +4496,21 @@ check_set(S,Type,Components) ->
 	    {false,TableCInf,NewComponents}
     end.
 
-
-%% check that all tags are distinct according to X.680 26.3
-check_distinct_tags({C1,C2,C3},Acc) when is_list(C1),is_list(C2),is_list(C3) ->
-    check_distinct_tags(C1++C2++C3,Acc);
-check_distinct_tags({C1,C2},Acc) when is_list(C1),is_list(C2) ->
-    check_distinct_tags(C1++C2,Acc);
-check_distinct_tags([#'ComponentType'{tags=[T]}|Cs],Acc) ->
-    check_distinct(T,Acc),
-    check_distinct_tags(Cs,[T|Acc]);
-check_distinct_tags([C=#'ComponentType'{tags=[T|Ts]}|Cs],Acc) ->
-    check_distinct(T,Acc),
-    check_distinct_tags([C#'ComponentType'{tags=Ts}|Cs],[T|Acc]);
-check_distinct_tags([#'ComponentType'{tags=[]}|_Cs],_Acc) ->
-    throw({error,"Not distinct tags in SET"});
-check_distinct_tags([],_) ->
-    ok.
-check_distinct(T,Acc) ->
-    case lists:member(T,Acc) of
-	true ->
-	    throw({error,"Not distinct tags in SET"});
-	_ -> ok
-    end.
+collect_components({C1,C2,C3}) ->
+    collect_components(C1++C2++C3);
+collect_components({C1,C2}) ->
+    collect_components(C1++C2);
+collect_components(Cs) ->
+    %% Assert that tags are not empty
+    [] = [EmptyTag || EmptyTag = #'ComponentType'{tags=[]} <- Cs],
+    Cs.
 
 %% sorting in canonical order according to X.680 8.6, X.691 9.2
 %% DER: all components shall be sorted in canonical order.
 %% PER: only root components shall be sorted in canonical order. The
 %%      extension components shall remain in textual order.
 %%
-sort_components(der,S=#state{tname=TypeName},Components) ->
+sort_components(der, S, Components) ->
     {R1,Ext,R2} = extension(textual_order(Components)),
     CompsList = case Ext of
 		    noext -> R1;
@@ -5464,88 +4518,34 @@ sort_components(der,S=#state{tname=TypeName},Components) ->
 		end,
     case {untagged_choice(S,CompsList),Ext} of
 	{false,noext} ->
-	    {true,sort_components1(S,TypeName,CompsList,[],[],[],[])};
+	    {true,sort_components1(CompsList)};
 	{false,_} ->
-	    {true,{sort_components1(S,TypeName,CompsList,[],[],[],[]), []}};
+	    {true,{sort_components1(CompsList),[]}};
 	{true,noext} ->
 	    %% sort in run-time
 	    {dynamic,R1};
 	_ ->
 	    {dynamic,{R1, Ext, R2}}
     end;
-sort_components(per,S=#state{tname=TypeName},Components) ->
+sort_components(per, S, Components) ->
     {R1,Ext,R2} = extension(textual_order(Components)),
     Root = tag_untagged_choice(S,R1++R2),
     case Ext of
 	noext ->
-	    {true,sort_components1(S,TypeName,Root,[],[],[],[])};
+	    {true,sort_components1(Root)};
 	_ ->
-	    {true,{sort_components1(S,TypeName,Root,[],[],[],[]),
-		   Ext}}
+	    {true,{sort_components1(Root),Ext}}
     end.
 
-sort_components1(S,TypeName,[C=#'ComponentType'{tags=[{'UNIVERSAL',_}|_R]}|Cs],
-		 UnivAcc,ApplAcc,ContAcc,PrivAcc) ->
-    sort_components1(S,TypeName,Cs,[C|UnivAcc],ApplAcc,ContAcc,PrivAcc);
-sort_components1(S,TypeName,[C=#'ComponentType'{tags=[{'APPLICATION',_}|_R]}|Cs],
-		 UnivAcc,ApplAcc,ContAcc,PrivAcc) ->
-    sort_components1(S,TypeName,Cs,UnivAcc,[C|ApplAcc],ContAcc,PrivAcc);
-sort_components1(S,TypeName,[C=#'ComponentType'{tags=[{'CONTEXT',_}|_R]}|Cs],
-		 UnivAcc,ApplAcc,ContAcc,PrivAcc) ->
-    sort_components1(S,TypeName,Cs,UnivAcc,ApplAcc,[C|ContAcc],PrivAcc);
-sort_components1(S,TypeName,[C=#'ComponentType'{tags=[{'PRIVATE',_}|_R]}|Cs],
-		 UnivAcc,ApplAcc,ContAcc,PrivAcc) ->
-    sort_components1(S,TypeName,Cs,UnivAcc,ApplAcc,ContAcc,[C|PrivAcc]);
-sort_components1(S,TypeName,[],UnivAcc,ApplAcc,ContAcc,PrivAcc) ->
-    I = #'ComponentType'.tags,
-    ascending_order_check(S,TypeName,sort_universal_type(UnivAcc)) ++
-	ascending_order_check(S,TypeName,lists:keysort(I,ApplAcc)) ++
-	ascending_order_check(S,TypeName,lists:keysort(I,ContAcc)) ++
-	ascending_order_check(S,TypeName,lists:keysort(I,PrivAcc)).
-
-ascending_order_check(S,TypeName,Components) ->
-    ascending_order_check1(S,TypeName,Components),
-    Components.
-
-ascending_order_check1(S,TypeName,
-		       [C1 = #'ComponentType'{tags=[{_,T}|_]},
-			C2 = #'ComponentType'{tags=[{_,T}|_]}|Rest]) ->
-    asn1ct:warning("Indistinct tag ~p in SET ~p, components ~p and ~p~n",
-		   [T,TypeName,C1#'ComponentType'.name,C2#'ComponentType'.name],S,
-		   "Indistinct tag in SET"),
-    ascending_order_check1(S,TypeName,[C2|Rest]);
-ascending_order_check1(S,TypeName,
-		       [C1 = #'ComponentType'{tags=[{'UNIVERSAL',T1}|_]},
-			C2 = #'ComponentType'{tags=[{'UNIVERSAL',T2}|_]}|Rest]) ->
-    case (decode_type(T1) == decode_type(T2)) of
-	true ->
-	    asn1ct:warning("Indistinct tags ~p and ~p in"
-			   " SET ~p, components ~p and ~p~n",
-			   [T1,T2,TypeName,C1#'ComponentType'.name,
-			    C2#'ComponentType'.name],S,
-			   "Indistinct tags and in SET"),
-	    ascending_order_check1(S,TypeName,[C2|Rest]);
-	_ ->
-	    ascending_order_check1(S,TypeName,[C2|Rest])
-    end;
-ascending_order_check1(S,N,[_|Rest]) ->
-    ascending_order_check1(S,N,Rest);
-ascending_order_check1(_,_,[]) ->
-    ok.
-    
-sort_universal_type(Components) ->
-    List = lists:map(fun(C) ->
-			     #'ComponentType'{tags=[{_,T}|_]} = C,
-			     {decode_type(T),C}
-		     end,
-		     Components),
-    SortedList = lists:keysort(1,List),
-    lists:map(fun(X)->element(2,X) end,SortedList).
-
-decode_type(I) when is_integer(I) ->
-    I;
-decode_type(T) ->
-    asn1ct_gen_ber_bin_v2:decode_type(T).
+sort_components1(Cs0) ->
+    Cs1 = [{tag_key(Tag),C} || #'ComponentType'{tags=[Tag|_]}=C <- Cs0],
+    Cs = lists:sort(Cs1),
+    [C || {_,C} <- Cs].
+
+tag_key({'UNIVERSAL',Tag}) ->   {0,Tag};
+tag_key({'APPLICATION',Tag}) -> {1,Tag};
+tag_key({'CONTEXT',Tag}) ->     {2,Tag};
+tag_key({'PRIVATE',Tag}) ->     {3,Tag}.
 
 untagged_choice(_S,[#'ComponentType'{typespec=#type{tag=[],def={'CHOICE',_}}}|_Rest]) ->
     true;
@@ -5641,35 +4641,43 @@ check_selectiontype(S,Name,#type{def=Eref})
     {RefMod,TypeDef} = get_referenced_type(S,Eref),
     NewS = S#state{module=load_asn1_module(S,RefMod),
 		   mname=RefMod,
-		   type=TypeDef,
 		   tname=get_datastr_name(TypeDef)},
     check_selectiontype2(NewS,Name,TypeDef);
 check_selectiontype(S,Name,Type=#type{def={pt,_,_}}) ->
-    TName =
-	case S#state.recordtopname of
-	    [] ->
-		S#state.tname;
-	    N -> N
-	end,
+    TName = case S#state.recordtopname of
+		[] -> S#state.tname;
+		N -> N
+	    end,
     TDef = #typedef{name=TName,typespec=Type},
     check_selectiontype2(S,Name,TDef);
-check_selectiontype(S,Name,Type) ->
-    Msg = lists:flatten(io_lib:format("SelectionType error: ~w < ~w must be a reference to a CHOICE.",[Name,Type])),
-    error({type,Msg,S}).
+check_selectiontype(S, _Name, Type) ->
+    asn1_error(S, {illegal_choice_type, error_value(Type)}).
 
 check_selectiontype2(S,Name,TypeDef) ->
     NewS = S#state{recordtopname=get_datastr_name(TypeDef)},
-    CheckedType = check_type(NewS,TypeDef,TypeDef#typedef.typespec),
-    Components = get_choice_components(S,CheckedType#type.def),
-    case lists:keysearch(Name,#'ComponentType'.name,Components) of
-	{value,C} -> 
-	    %% The selected type will have the tag of the selected type.
-	    _T = C#'ComponentType'.typespec;
-%	    T#type{tag=def_to_tag(NewS,T#type.def)};
-	_ -> 
-	    Msg = lists:flatten(io_lib:format("error checking SelectionType: ~w~n",[Name])),
-	    error({type,Msg,S})
+    Components =
+	try
+	    CheckedType = check_type(NewS,TypeDef,TypeDef#typedef.typespec),
+	    get_choice_components(S,CheckedType#type.def)
+	catch error:_ ->
+		asn1_error(S, {illegal_choice_type, error_value(TypeDef)})
+	end,
+    case lists:keyfind(Name, #'ComponentType'.name, Components) of
+	#'ComponentType'{typespec=TS} -> TS;
+	false -> asn1_error(S, {illegal_id, error_value(Name)})
     end.
+
+
+get_choice_components(_S,{'CHOICE',Components}) when is_list(Components)->
+    Components;
+get_choice_components(_S,{'CHOICE',{C1,C2}}) when is_list(C1),is_list(C2) ->
+    C1++C2;
+get_choice_components(S,ERef=#'Externaltypereference'{}) ->
+    {_RefMod,TypeDef}=get_referenced_type(S,ERef),
+    #typedef{typespec=TS} = TypeDef,
+    get_choice_components(S,TS#type.def).
+
+
 	    
 check_restrictedstring(_S,_Def,_Constr) ->
     ok.
@@ -5702,7 +4710,7 @@ check_choice(S,Type,Components) when is_list(Components) ->
 	    check_unique_tags(S, NewComps3),
 	    complist_as_tuple(NewComps3);
 	Dupl ->
-	    throw({error,{asn1,{duplicate_choice_alternatives,Dupl}}})
+	    asn1_error(S, {duplicate_identifier,error_value(hd(Dupl))})
     end;
 check_choice(_S,_,[]) -> 
     [].
@@ -5799,25 +4807,30 @@ check_unique_tags(S,C) ->
     case (S#state.module)#module.tagdefault of
 	'AUTOMATIC' ->
 	    case any_manual_tag(C) of
-		false -> true;
-		_ -> collect_and_sort_tags(C,[])
+		false ->
+		    true;
+		true ->
+		    check_unique_tags(S, C, [])
 	    end;
 	_ ->
-    	    collect_and_sort_tags(C,[])
+	    check_unique_tags(S, C, [])
     end.
 
-collect_and_sort_tags([C|Rest],Acc) when is_record(C,'ComponentType') ->
-    collect_and_sort_tags(Rest,C#'ComponentType'.tags ++ Acc);
-collect_and_sort_tags([_|Rest],Acc) ->
-    collect_and_sort_tags(Rest,Acc);
-collect_and_sort_tags([],Acc) ->
-    {Dupl,_}= lists:mapfoldl(fun(El,El)->{{dup,El},El};(El,_Prev)-> {El,El} end,notag,lists:sort(Acc)),
-    Dupl2 = [Dup|| {dup,Dup} <- Dupl],
-    if 
-	length(Dupl2) > 0 ->
-	    throw({error,{asn1,{duplicates_of_the_tags,Dupl2}}});
-	true ->
-	    true
+check_unique_tags(S, [#'ComponentType'{name=Name,tags=Tags0}|T], Acc) ->
+    Tags = [{Tag,Name} || Tag <- Tags0],
+    check_unique_tags(S, T, Tags ++ Acc);
+check_unique_tags(S, [_|T], Acc) ->
+    check_unique_tags(S, T, Acc);
+check_unique_tags(S, [], Acc) ->
+    R0 = sofs:relation(Acc),
+    R1 = sofs:relation_to_family(R0),
+    R2 = sofs:to_external(R1),
+    Dup = [Els || {_,[_,_|_]=Els} <- R2],
+    case Dup of
+	[] ->
+	    ok;
+	[FirstDupl|_] ->
+	    asn1_error(S, {duplicate_tags,FirstDupl})
     end.
 
 check_unique(L,Pos) ->
@@ -5959,28 +4972,18 @@ componentrelation_leadingattr(S,[C= #'ComponentType'{}|Cs],CompList,Acc,CompAcc)
 			{[],C};
 		    [{ObjSet,Attr,N,ClassDef,_Path,ValueIndex}|_NewRest] ->
 			OS = object_set_mod_name(S,ObjSet),
-			UniqueFieldName = 
-			    case (catch get_unique_fieldname(S,#classdef{typespec=ClassDef})) of
-				{error,'__undefined_',_} ->
-				    no_unique;
-				{asn1,Msg,_} ->
-				    error({type,Msg,S});
-				{'EXIT',Msg} ->
-				    error({type,{internal_error,Msg},S});
-				{Other,_} -> Other
-			    end,
-%			UsedFieldName = get_used_fieldname(S,Attr,STList),
+			UniqFN = get_unique_fieldname(S,
+						      #classdef{typespec=ClassDef}),
 			%% Res should be done differently: even though
 			%% a unique field name exists it is not
 			%% certain that the ObjectClassFieldType of
 			%% the simple table constraint picks that
 			%% class field.
 			Res = #simpletableattributes{objectsetname=OS,
-%%						     c_name=asn1ct_gen:un_hyphen_var(Attr),
 						     c_name=Attr,
 						     c_index=N,
-						     usedclassfield=UniqueFieldName,
-						     uniqueclassfield=UniqueFieldName,
+						     usedclassfield=UniqFN,
+						     uniqueclassfield=UniqFN,
 						     valueindex=ValueIndex},
 			{[Res],C#'ComponentType'{typespec=NewTSpec}}
 		end;
@@ -6033,7 +5036,7 @@ remove_doubles1(El,L) ->
 	NewL -> remove_doubles1(El,NewL)
     end.
 
-%% get_simple_table_info searches the commponents Cs by the path from
+%% get_simple_table_info searches the components Cs by the path from
 %% an at-list (third argument), and follows into a component of it if
 %% necessary, to get information needed for code generating.
 %%
@@ -6048,32 +5051,35 @@ remove_doubles1(El,L) ->
 % %% at least one step below the outermost level, i.e. the leading
 % %% information shall be on a sub level. 2) They don't have any common
 % %% path.
-get_simple_table_info(S,Cs,[AtList|Rest]) ->
-    [get_simple_table_info1(S,Cs,AtList,[])|get_simple_table_info(S,Cs,Rest)];
-get_simple_table_info(_,_,[]) ->
-    [].
-get_simple_table_info1(S,Cs,[Cname|Cnames],Path) when is_list(Cs) ->
-    case lists:keysearch(Cname,#'ComponentType'.name,Cs) of
-	{value,C} ->
-	    get_simple_table_info1(S,C,Cnames,[Cname|Path]);
-        _ ->
-	    error({type,"Missing expected simple table constraint",S})
-    end;
-get_simple_table_info1(S,#'ComponentType'{typespec=TS},[],Path) ->
-    %% In this component there must be a simple table constraint
-    %% o.w. the asn1 code is wrong.
-    #type{def=OCFT,constraint=Cnstr} = TS,
-    case constraint_member(simpletable,Cnstr) of
-	{true,{simpletable,_OSRef}} ->
-	    simple_table_info(S,OCFT,Path);
-	_ ->
-	    error({type,{"missing expected simple table constraint",
-			 Cnstr},S})
+get_simple_table_info(S, Cs, AtLists) ->
+    [get_simple_table_info1(S, Cs, AtList, []) || AtList <- AtLists].
+
+get_simple_table_info1(S, Cs, [Cname|Cnames], Path) ->
+    #'ComponentType'{} = C =
+	lists:keyfind(Cname, #'ComponentType'.name, Cs),
+    get_simple_table_info2(S, C, Cnames, [Cname|Path]).
+
+get_simple_table_info2(S, #'ComponentType'{name=Name,typespec=TS}, [], Path) ->
+    OCFT = simple_table_get_ocft(S, Name, TS),
+    case lists:keymember(simpletable, 1, TS#type.constraint) of
+	true ->
+	    simple_table_info(S, OCFT, Path);
+	false ->
+	    asn1_error(S, {missing_table_constraint,Name})
     end;
-get_simple_table_info1(S,#'ComponentType'{typespec=TS},Cnames,Path) ->
+get_simple_table_info2(S, #'ComponentType'{typespec=TS}, Cnames, Path) ->
     Components = get_atlist_components(TS#type.def),
-    get_simple_table_info1(S,Components,Cnames,Path).
-
+    get_simple_table_info1(S, Components, Cnames, Path).
+
+simple_table_get_ocft(_, _, #type{def=#'ObjectClassFieldType'{}=OCFT}) ->
+    OCFT;
+simple_table_get_ocft(S, Component, #type{constraint=Constr}) ->
+    case lists:keyfind(ocft, 1, Constr) of
+	{ocft,OCFT} ->
+	    OCFT;
+	false ->
+	    asn1_error(S, {missing_ocft,Component})
+    end.
 
 simple_table_info(S,#'ObjectClassFieldType'{classname=ClRef,
 					    class=ObjectClass,
@@ -6096,19 +5102,8 @@ simple_table_info(S,#'ObjectClassFieldType'{classname=ClRef,
 		CDef;
 	    _ -> #classdef{typespec=ObjectClass}
 	end,
-    UniqueName =
-	case (catch get_unique_fieldname(S,ClassDef)) of
-	    {error,'__undefined_',_} -> no_unique;
-	    {asn1,Msg,_} ->
-		error({type,Msg,S});
-	    {'EXIT',Msg} ->
-		error({type,{internal_error,Msg},S});
-	    {Other,_} -> Other
-	end,
-    {lists:reverse(Path),ObjectClassFieldName,UniqueName};
-simple_table_info(S,Type,_) ->
-    error({type,{"the type referenced by a componentrelation constraint must be a ObjectClassFieldType",Type},S}).
-
+    UniqueName = get_unique_fieldname(S, ClassDef),
+    {lists:reverse(Path),ObjectClassFieldName,UniqueName}.
 
 %% any_component_relation searches for all component relation
 %% constraints that refers to the actual level and returns a list of
@@ -6122,9 +5117,8 @@ simple_table_info(S,Type,_) ->
 %% is found to check the validity of the at-list.
 any_component_relation(S,[#'ComponentType'{name=CName,typespec=Type}|Cs],CNames,NamePath,Acc) ->
     CRelPath =
-	case constraint_member(componentrelation,Type#type.constraint) of
-%%	    [{componentrelation,_,AtNotation}] ->
-	    {true,{_,_,AtNotation}} ->
+	case lists:keyfind(componentrelation, 1, Type#type.constraint) of
+	    {_,_,AtNotation} ->
 		%% Found component relation constraint, now check
 		%% whether this constraint is relevant for the level
 		%% where the search started
@@ -6133,7 +5127,7 @@ any_component_relation(S,[#'ComponentType'{name=CName,typespec=Type}|Cs],CNames,
 		%% simple table constraint from where the component
 		%% relation is found.
 		evaluate_atpath(S,NamePath,CNames,AtNot);
-	    _ ->
+	    false ->
 		[]
 	end,
     InnerAcc =
@@ -6155,11 +5149,11 @@ any_component_relation(S,[#'ComponentType'{name=CName,typespec=Type}|Cs],CNames,
     any_component_relation(S,Cs,CNames,NamePath,InnerAcc++CRelPath++Acc);
 any_component_relation(S,Type,CNames,NamePath,Acc) when is_record(Type,type) ->
     CRelPath =
-	case constraint_member(componentrelation,Type#type.constraint) of
-	    {true,{_,_,AtNotation}} ->
+	case lists:keyfind(componentrelation, 1, Type#type.constraint) of
+	    {_,_,AtNotation} ->
 		AtNot = extract_at_notation(AtNotation),
 		evaluate_atpath(S,NamePath,CNames,AtNot);
-	    _ ->
+	    false ->
 		[]
 	end,
     InnerAcc =
@@ -6181,15 +5175,6 @@ any_component_relation(S,['ExtensionAdditionGroupEnd'|Cs],CNames,NamePath,Acc) -
 any_component_relation(_,[],_,_,Acc) ->
     Acc.
 
-constraint_member(componentrelation,[CRel={componentrelation,_,_}|_Rest]) ->
-    {true,CRel};
-constraint_member(simpletable,[ST={simpletable,_}|_Rest]) ->
-    {true,ST};
-constraint_member(Key,[_H|T]) ->
-    constraint_member(Key,T);
-constraint_member(_,[]) ->
-    false.
-    
 %% evaluate_atpath/4 finds out whether the at notation refers to the
 %% search level. The list of referenced names in the AtNot list shall
 %% begin with a name that exists on the level it refers to. If the
@@ -6223,9 +5208,7 @@ evaluate_atpath(S=#state{abscomppath=TopPath},NamePath,Cnames,{outermost,AtPath=
 	{_,[H|_T]} ->
 	    case lists:member(H,Cnames) of
 		true -> [AtPathBelowTop];
-		_ -> 
-		 %% error({type,{asn1,"failed to analyze at-path",AtPath},S})
-		    throw({type,{asn1,"failed to analyze at-path",AtPath},S})
+		_ -> asn1_error(S, {invalid_at_path, AtPath})
 	    end
     end;
 evaluate_atpath(_,_,_,_) ->
@@ -6262,23 +5245,8 @@ tuple2complist({R1,E,R2}) ->
 tuple2complist(List) when is_list(List) ->
     List.
 
-get_choice_components(_S,{'CHOICE',Components}) when is_list(Components)->
-    Components;
-get_choice_components(_S,{'CHOICE',{C1,C2}}) when is_list(C1),is_list(C2) ->
-    C1++C2;
-get_choice_components(S,ERef=#'Externaltypereference'{}) ->
-    {_RefMod,TypeDef}=get_referenced_type(S,ERef),
-    #typedef{typespec=TS} = TypeDef,
-    get_choice_components(S,TS#type.def).
-
-extract_at_notation([{Level,[#'Externalvaluereference'{value=Name}|Rest]}]) ->
-    {Level,[Name|extract_at_notation1(Rest)]};
-extract_at_notation(At) ->
-    exit({error,{asn1,{at_notation,At}}}).
-extract_at_notation1([#'Externalvaluereference'{value=Name}|Rest]) ->
-    [Name|extract_at_notation1(Rest)];
-extract_at_notation1([]) ->
-    [].
+extract_at_notation([{Level,ValueRefs}]) ->
+    {Level,[Name || #'Externalvaluereference'{value=Name} <- ValueRefs]}.
     
 %% componentrelation1/1 identifies all componentrelation constraints
 %% that exist in C or in the substructure of C. Info about the found
@@ -6297,8 +5265,8 @@ componentrelation1(S,C = #type{def=Def,constraint=Constraint,tablecinf=TCI},
     Ret =
 %	case Constraint of
 %	    [{componentrelation,{_,_,ObjectSet},AtList}|_Rest] ->
-	case constraint_member(componentrelation,Constraint) of
-	    {true,{_,{_,_,ObjectSet},AtList}} ->
+	case lists:keyfind(componentrelation, 1, Constraint) of
+	    {_,{_,_,ObjectSet},AtList} ->
 		[{_,AL=[#'Externalvaluereference'{}|_R1]}|_R2] = AtList,
 		%% Note: if Path is longer than one,i.e. it is within
 		%% an inner type of the actual level, then the only
@@ -6309,7 +5277,7 @@ componentrelation1(S,C = #type{def=Def,constraint=Constraint,tablecinf=TCI},
 		    lists:map(fun(#'Externalvaluereference'{value=V})->V end,
 			      AL),
 		{[{ObjectSet,AtPath,ClassDef,Path}],Def};
-	    _ ->
+	    false ->
 		%% check the inner type of component
 		innertype_comprel(S,Def,Path)
 	end,
@@ -6383,10 +5351,8 @@ componentlist_comprel(_,[],Acc,_,NewCL) ->
 
 innertype_comprel1(S,T = #type{def=Def,constraint=Cons,tablecinf=TCI},Path) ->
     Ret =
-%	case Cons of
-%	    [{componentrelation,{_,_,ObjectSet},AtList}|_Rest] ->
-	case constraint_member(componentrelation,Cons) of
-	    {true,{_,{_,_,ObjectSet},AtList}} ->
+	case lists:keyfind(componentrelation, 1, Cons) of
+	    {_,{_,_,ObjectSet},AtList} ->
 		%% This AtList must have an "outermost" at sign to be
 		%% relevent here.
 		[{_,AL=[#'Externalvaluereference'{value=_Attr}|_R1]}|_R2] 
@@ -6397,7 +5363,7 @@ innertype_comprel1(S,T = #type{def=Def,constraint=Cons,tablecinf=TCI},Path) ->
 		    lists:map(fun(#'Externalvaluereference'{value=V})->V end,
 			      AL),
 		[{ObjectSet,AtPath,ClassDef,Path}];
-	    _ ->
+	    false ->
 		innertype_comprel(S,Def,Path)
 	end,
     case Ret of
@@ -6465,8 +5431,7 @@ value_match(S,#'ComponentType'{typespec=Type},Name,[At|Ats],Acc) ->
     InnerType = asn1ct_gen:get_inner(Type#type.def),
     Components =
 	case get_atlist_components(Type#type.def) of
-	    [] -> error({type,{asn1,"element in at list must be a "
-			       "SEQUENCE, SET or CHOICE.",Name},S});
+	    [] -> asn1_error(S, {invalid_element, Name});
 	    Comps -> Comps
 	end,
     {Index,ValueIndex} = component_value_index(S,InnerType,At,Components),
@@ -6486,29 +5451,27 @@ component_index1(_S,Name,[#'ComponentType'{name=Name}|_Cs],N) ->
 component_index1(S,Name,[_C|Cs],N) ->
     component_index1(S,Name,Cs,N+1);
 component_index1(S,Name,[],_) ->
-    error({type,{asn1,"component of at-list was not"
-		 " found in substructure",Name},S}).
+    asn1_error(S, {invalid_at_list, Name}).
 
-get_unique_fieldname(_S,ClassDef) when is_record(ClassDef,classdef) ->
-%%    {_,Fields,_} = ClassDef#classdef.typespec,
-    Fields = (ClassDef#classdef.typespec)#objectclass.fields,
-    get_unique_fieldname1(Fields,[]);
+get_unique_fieldname(S, #classdef{typespec=TS}) ->
+    Fields = TS#objectclass.fields,
+    get_unique_fieldname1(S, Fields, []);
 get_unique_fieldname(S,#typedef{typespec=#type{def=ClassRef}}) ->
     %% A class definition may be referenced as
     %% REFED-CLASS ::= DEFINED-CLASS and then REFED-CLASS is a typedef
     {_M,ClassDef} = get_referenced_type(S,ClassRef),
     get_unique_fieldname(S,ClassDef).
 
-get_unique_fieldname1([],[]) ->
-    throw({error,'__undefined_',[]});
-get_unique_fieldname1([],[Name]) ->
-    Name;
-get_unique_fieldname1([],Acc) ->
-    throw({asn1,'only one UNIQUE field is allowed in CLASS',Acc});
-get_unique_fieldname1([{fixedtypevaluefield,Name,_,'UNIQUE',Opt}|Rest],Acc) ->
-    get_unique_fieldname1(Rest,[{Name,Opt}|Acc]);
-get_unique_fieldname1([_H|T],Acc) ->
-    get_unique_fieldname1(T,Acc).
+get_unique_fieldname1(S, [{fixedtypevaluefield,Name,_,'UNIQUE',Opt}|T], Acc) ->
+    get_unique_fieldname1(S, T, [{Name,Opt}|Acc]);
+get_unique_fieldname1(S, [_|T], Acc) ->
+    get_unique_fieldname1(S, T, Acc);
+get_unique_fieldname1(S, [], Acc) ->
+    case Acc of
+	[] -> no_unique;
+	[Name] -> Name;
+	[_|_] -> asn1_error(S, multiple_uniqs)
+    end.
 
 get_tableconstraint_info(S,Type,{CheckedTs,EComps,CheckedTs2}) ->
     {get_tableconstraint_info(S,Type,CheckedTs,[]),
@@ -6564,31 +5527,8 @@ get_tableconstraint_info(S,Type,[C|Cs],Acc) ->
 
 get_referenced_fieldname([{_,FirstFieldname}]) ->
     {FirstFieldname,[]};
-get_referenced_fieldname([{_,FirstFieldname}|Rest]) ->
-    {FirstFieldname,lists:map(fun(X)->element(2,X) end,Rest)};
-get_referenced_fieldname(Def={FieldName,RestFieldName}) when is_atom(FieldName),is_list(RestFieldName)->
-    Def;
-get_referenced_fieldname(Def) ->
-    {no_type,Def}.
-
-%% get_ObjectClassFieldType extracts the type from the chain of
-%% objects that leads to a final type.
-get_ObjectClassFieldType(S,ERef,PrimFieldNameList) when
-  is_record(ERef,'Externaltypereference') ->
-    {MName,Type} = get_referenced_type(S,ERef),
-    NewS = update_state(S#state{type=Type,
-		   tname=ERef#'Externaltypereference'.type},MName),
-    ClassSpec = check_class(NewS,Type),
-    Fields = ClassSpec#objectclass.fields,
-    get_ObjectClassFieldType(S,Fields,PrimFieldNameList);
-get_ObjectClassFieldType(S,Fields,L=[_PrimFieldName1|_Rest]) ->
-    check_PrimitiveFieldNames(S,Fields,L),
-    get_OCFType(S,Fields,L);
-get_ObjectClassFieldType(S,ERef,{FieldName,Rest}) ->
-    get_ObjectClassFieldType(S,ERef,Rest ++ [FieldName]).
-
-check_PrimitiveFieldNames(_S,_Fields,_) ->
-    ok.
+get_referenced_fieldname([{_,FirstFieldname}|T]) ->
+    {FirstFieldname,[element(2, X) || X <- T]}.
 
 %% get_ObjectClassFieldType_classdef gets the def of the class of the
 %% ObjectClassFieldType, i.e. the objectclass record. If the type has
@@ -6609,15 +5549,13 @@ get_OCFType(S,Fields,[PrimFieldName|Rest]) ->
 	    {fixedtypevaluefield,PrimFieldName,Type};
 	{value,{objectfield,_,ClassRef,_Unique,_OptSpec}} ->
 	    {MName,ClassDef} = get_referenced_type(S,ClassRef),
-	    NewS = update_state(S#state{type=ClassDef,
-					tname=get_datastr_name(ClassDef)},
+	    NewS = update_state(S#state{tname=get_datastr_name(ClassDef)},
 				MName),
 	    CheckedCDef = check_class(NewS,ClassDef),
 	    get_OCFType(S,CheckedCDef#objectclass.fields,Rest);
 	{value,{objectsetfield,_,Type,_OptSpec}} ->
 	    {MName,ClassDef} = get_referenced_type(S,Type#type.def),
-	    NewS = update_state(S#state{type=ClassDef,
-					tname=get_datastr_name(ClassDef)},
+	    NewS = update_state(S#state{tname=get_datastr_name(ClassDef)},
 				MName),
 	    CheckedCDef = check_class(NewS,ClassDef),
 	    get_OCFType(S,CheckedCDef#objectclass.fields,Rest);
@@ -6625,7 +5563,7 @@ get_OCFType(S,Fields,[PrimFieldName|Rest]) ->
 	{value,Other} ->
 	    {element(1,Other),PrimFieldName};
 	_  ->
-	    throw({error,lists:flatten(io_lib:format("undefined FieldName in ObjectClassFieldType: ~w",[PrimFieldName]))})
+	    asn1_error(S, {illegal_object_field, PrimFieldName})
     end.
 
 get_taglist(S,Ext) when is_record(Ext,'Externaltypereference') ->
@@ -6649,30 +5587,8 @@ get_taglist(_S,#'ObjectClassFieldType'{type={typefield,_}}) ->
     [];
 get_taglist(S,#'ObjectClassFieldType'{type={fixedtypevaluefield,_,Type}}) ->
     get_taglist(S,Type);
-get_taglist(S,{ERef=#'Externaltypereference'{},FieldNameList})
-  when is_list(FieldNameList) ->
-    case get_ObjectClassFieldType(S,ERef,FieldNameList) of
-	{fixedtypevaluefield,_,Type} -> get_taglist(S,Type);
-	{TypeFieldName,_} when is_atom(TypeFieldName) -> []%should check if allowed
-    end;
-get_taglist(S,{ObjCl,FieldNameList}) when is_record(ObjCl,objectclass),
-					  is_list(FieldNameList) ->
-    case get_ObjectClassFieldType(S,ObjCl#objectclass.fields,FieldNameList) of
-	{fixedtypevaluefield,_,Type} -> get_taglist(S,Type);
-	{TypeFieldName,_} when is_atom(TypeFieldName) -> []%should check if allowed
-    end;
-get_taglist(S,Def) ->
-    case S#state.erule of
-	ber ->
-	    [];
-	_ ->
-	    case Def of
-		'ASN1_OPEN_TYPE' -> % open_type has no UNIVERSAL tag as such
-		    [];
-		_ ->
-		    [asn1ct_gen:def_to_tag(Def)]
-	    end
-    end.
+get_taglist(_, _) ->
+    [].
 
 get_taglist1(S,[#'ComponentType'{name=_Cname,tags=TagL}|Rest]) when is_list(TagL) -> 
     %% tag_list has been here , just return TagL and continue with next alternative
@@ -6729,15 +5645,6 @@ get_taglist1(_S,[]) ->
 %% tag_number('CHARACTER STRING') -> 29;
 %% tag_number('BMPString') -> 30.
 
-
-dbget_ex(_S,Module,Key) ->
-    case asn1_db:dbget(Module,Key) of
-	undefined ->
-	    
-	    throw({error,{asn1,{undefined,{Module,Key}}}}); % this is catched on toplevel type or value
-	T -> T
-    end.
-
 merge_tags(T1, T2) when is_list(T2) ->
     merge_tags2(T1 ++ T2, []);
 merge_tags(T1, T2) ->
@@ -6747,80 +5654,53 @@ merge_tags2([T1= #tag{type='IMPLICIT'}, T2 |Rest], Acc) ->
     merge_tags2([T1#tag{type=T2#tag.type, form=T2#tag.form}|Rest],Acc);
 merge_tags2([T1= #tag{type={default,'IMPLICIT'}}, T2 |Rest], Acc) ->
     merge_tags2([T1#tag{type=T2#tag.type, form=T2#tag.form}|Rest],Acc);
+merge_tags2([T1= #tag{type={default,'AUTOMATIC'}}, T2 |Rest], Acc) ->
+    merge_tags2([T1#tag{type=T2#tag.type, form=T2#tag.form}|Rest],Acc);
 merge_tags2([H|T],Acc) ->
     merge_tags2(T, [H|Acc]);
 merge_tags2([], Acc) ->
     lists:reverse(Acc).
 
-%% merge_constraints(C1, []) ->
-%%     C1;
-%% merge_constraints([], C2) ->
-%%     C2;
-%% merge_constraints(C1, C2) ->
-%%     {SList,VList,PAList,Rest} = splitlist(C1++C2,[],[],[],[]),
-%%     SizeC = merge_constraints(SList),
-%%     ValueC = merge_constraints(VList),
-%%     PermAlphaC = merge_constraints(PAList),
-%%     case Rest of
-%%         [] ->
-%%             SizeC ++ ValueC ++ PermAlphaC;
-%%         _ ->
-%%             throw({error,{asn1,{not_implemented,{merge_constraints,Rest}}}})
-%%     end.
-    
-%% merge_constraints([]) -> [];
-%% merge_constraints([C1 = {_,{Low1,High1}},{_,{Low2,High2}}|Rest]) when Low1 >= Low2,
-%%                                                                       High1 =< High2 ->
-%%     merge_constraints([C1|Rest]);
-%% merge_constraints([C1={'PermittedAlphabet',_},C2|Rest]) ->
-%%     [C1|merge_constraints([C2|Rest])];
-%% merge_constraints([C1 = {_,{_Low1,_High1}},C2 = {_,{_Low2,_High2}}|_Rest]) ->
-%%     throw({error,asn1,{conflicting_constraints,{C1,C2}}});
-%% merge_constraints([C]) ->
-%%     [C].
-
-%% splitlist([C={'SizeConstraint',_}|Rest],Sacc,Vacc,PAacc,Restacc) ->
-%%     splitlist(Rest,[C|Sacc],Vacc,PAacc,Restacc);
-%% splitlist([C={'ValueRange',_}|Rest],Sacc,Vacc,PAacc,Restacc) ->
-%%     splitlist(Rest,Sacc,[C|Vacc],PAacc,Restacc);
-%% splitlist([C={'PermittedAlphabet',_}|Rest],Sacc,Vacc,PAacc,Restacc) ->
-%%     splitlist(Rest,Sacc,Vacc,[C|PAacc],Restacc);
-%% splitlist([C|Rest],Sacc,Vacc,PAacc,Restacc) ->
-%%     splitlist(Rest,Sacc,Vacc,PAacc,[C|Restacc]);
-%% splitlist([],Sacc,Vacc,PAacc,Restacc) ->
-%%     {lists:reverse(Sacc),
-%%      lists:reverse(Vacc),
-%%      lists:reverse(PAacc),
-%%      lists:reverse(Restacc)}.
-
-
-
-storeindb(S,M) when is_record(M,module) ->
-    TVlist = M#module.typeorval,
-    NewM = M#module{typeorval=findtypes_and_values(TVlist)},
-    asn1_db:dbnew(NewM#module.name),
-    asn1_db:dbput(NewM#module.name,'MODULE',  NewM),
-    Res = storeindb(#state{mname=NewM#module.name}, TVlist, []),
-    include_default_class(S,NewM#module.name),
+storeindb(S0, #module{name=ModName,typeorval=TVlist0}=M) ->
+    S = S0#state{mname=ModName},
+    TVlist1 = [{asn1ct:get_name_of_def(Def),Def} || Def <- TVlist0],
+    case check_duplicate_defs(S, TVlist1) of
+	ok ->
+	    storeindb_1(S, M, TVlist0, TVlist1);
+	{error,_}=Error ->
+	    Error
+    end.
+
+storeindb_1(S, #module{name=ModName}=M, TVlist0, TVlist) ->
+    NewM = M#module{typeorval=findtypes_and_values(TVlist0)},
+    asn1_db:dbnew(ModName, S#state.erule),
+    asn1_db:dbput(ModName, 'MODULE',  NewM),
+    asn1_db:dbput(ModName, TVlist),
+    include_default_class(S, NewM#module.name),
     include_default_type(NewM#module.name),
-    Res.
+    ok.
 
-storeindb(#state{mname=Module}=S, [H|T], Errors) ->
-    Name = asn1ct:get_name_of_def(H),
-    case asn1_db:dbget(Module, Name) of
-	undefined ->
-	    asn1_db:dbput(Module, Name, H),
-	    storeindb(S, T, Errors);
-	Prev ->
-	    PrevLine = asn1ct:get_pos_of_def(Prev),
-	    {error,Error} = asn1_error(S, H, {already_defined,Name,PrevLine}),
-	    storeindb(S, T, [Error|Errors])
-    end;
-storeindb(_, [], []) ->
-    ok;
-storeindb(_, [], [_|_]=Errors) ->
-    {error,Errors}.
+check_duplicate_defs(S, Defs) ->
+    Set0 = sofs:relation(Defs),
+    Set1 = sofs:relation_to_family(Set0),
+    Set = sofs:to_external(Set1),
+    case [duplicate_def(S, N, Dup) || {N,[_,_|_]=Dup} <- Set] of
+	[] ->
+	    ok;
+	[_|_]=E ->
+	    {error,lists:append(E)}
+    end.
+
+duplicate_def(S, Name, Dups0) ->
+    Dups1 = [{asn1ct:get_pos_of_def(Def),Def} || Def <- Dups0],
+    [{Prev,_}|Dups] = lists:sort(Dups1),
+    duplicate_def_1(S, Dups, Name, Prev).
 
+duplicate_def_1(S, [{_,Def}|T], Name, Prev) ->
+    E = return_asn1_error(S, Def, {already_defined,Name,Prev}),
+    [E|duplicate_def_1(S, T, Name, Prev)];
+duplicate_def_1(_, [], _, _) ->
+    [].
 
 findtypes_and_values(TVList) ->
     findtypes_and_values(TVList,[],[],[],[],[],[]).%% Types,Values,
@@ -6860,77 +5740,147 @@ findtypes_and_values([],Tacc,Vacc,Pacc,Cacc,Oacc,OSacc) ->
     {lists:reverse(Tacc),lists:reverse(Vacc),lists:reverse(Pacc),
      lists:reverse(Cacc),lists:reverse(Oacc),lists:reverse(OSacc)}.
     
-asn1_error(#state{mname=Where}, Item, Error) ->
+return_asn1_error(#state{error_context=Context}=S, Error) ->
+    return_asn1_error(S, Context, Error).
+
+return_asn1_error(#state{mname=Where}, Item, Error) ->
     Pos = asn1ct:get_pos_of_def(Item),
-    {error,{structured_error,{Where,Pos},?MODULE,Error}}.
+    {structured_error,{Where,Pos},?MODULE,Error}.
+
+-spec asn1_error(_, _) -> no_return().
+asn1_error(S, Error) ->
+    throw({error,return_asn1_error(S, Error)}).
 
 format_error({already_defined,Name,PrevLine}) ->
     io_lib:format("the name ~p has already been defined at line ~p",
 		  [Name,PrevLine]);
+format_error({duplicate_identifier,Ids}) ->
+    io_lib:format("the identifier '~p' has already been used", [Ids]);
+format_error({duplicate_tags,Elements}) ->
+    io_lib:format("duplicate tags in the elements: ~s",
+		  [format_elements(Elements)]);
+format_error({enum_illegal_redefinition,Id}) ->
+    io_lib:format("'~s' must not be redefined", [Id]);
+format_error({enum_not_ascending,Id,N,Prev}) ->
+    io_lib:format("the values for enumerations which follow '...' must "
+		  "be in ascending order, but '~p(~p)' is less than the "
+		  "previous value '~p'", [Id,N,Prev]);
+format_error({enum_reused_value,Id,Val}) ->
+    io_lib:format("'~s' has the value '~p' which is used more than once",
+		  [Id,Val]);
+format_error({illegal_id, Id}) ->
+    io_lib:format("illegal identifier: ~p", [Id]);
+format_error({illegal_choice_type, Ref}) ->
+    io_lib:format("expecting a CHOICE type: ~p", [Ref]);
+format_error({illegal_class_name,Class}) ->
+    io_lib:format("the class name '~s' is illegal (it must start with an uppercase letter and only contain uppercase letters, digits, or hyphens)", [Class]);
+format_error({illegal_COMPONENTS_OF, Ref}) ->
+    io_lib:format("expected a SEQUENCE or SET got: ~p", [Ref]);
+format_error(illegal_external_value) ->
+    "illegal value in EXTERNAL type";
+format_error({illegal_instance_of,Class}) ->
+    io_lib:format("using INSTANCE OF on class '~s' is illegal, "
+		  "because INSTANCE OF may only be used on the class TYPE-IDENTIFIER",
+		  [Class]);
+format_error(illegal_integer_value) ->
+    "expecting an integer value";
+format_error(illegal_object) ->
+    "expecting an object";
+format_error({illegal_object_field, Id}) ->
+    io_lib:format("expecting a class field: ~p",[Id]);
+format_error({illegal_oid,o_id}) ->
+    "illegal OBJECT IDENTIFIER";
+format_error({illegal_oid,rel_oid}) ->
+    "illegal RELATIVE-OID";
+format_error(illegal_octet_string_value) ->
+    "expecting a bstring or an hstring as value for an OCTET STRING";
+format_error({illegal_typereference,Name}) ->
+    io_lib:format("'~p' is used as a typereference, but does not start with an uppercase letter", [Name]);
+format_error(illegal_table_constraint) ->
+    "table constraints may only be applied to CLASS.&field constructs";
+format_error(illegal_value) ->
+    "expecting a value";
+format_error({illegal_value, TYPE}) ->
+    io_lib:format("expecting a ~s value", [TYPE]);
+format_error({invalid_fields,Fields,Obj}) ->
+    io_lib:format("invalid ~s in ~p", [format_fields(Fields),Obj]);
+format_error({invalid_bit_number,Bit}) ->
+    io_lib:format("the bit number '~p' is invalid", [Bit]);
+format_error(invalid_table_constraint) ->
+    "the table constraint is not an object set";
+format_error(invalid_objectset) ->
+    "expecting an object set";
+format_error({implicit_tag_before,Kind}) ->
+    "illegal implicit tag before " ++
+	case Kind of
+	    choice -> "'CHOICE'";
+	    open_type -> "open type"
+	end;
+format_error({missing_mandatory_fields,Fields,Obj}) ->
+    io_lib:format("missing mandatory ~s in ~p",
+		  [format_fields(Fields),Obj]);
+format_error({missing_table_constraint,Component}) ->
+    io_lib:format("the component '~s' is referenced by a component relation constraint using the '@field-name' notation, but does not have a table constraint",
+		  [Component]);
+format_error({missing_id,Id}) ->
+    io_lib:format("expected the mandatory component '~p'", [Id]);
+format_error({missing_ocft,Component}) ->
+    io_lib:format("the component '~s' must be an ObjectClassFieldType (CLASSNAME.&field-name)", [Component]);
+format_error(multiple_uniqs) ->
+    "implementation limitation: only one UNIQUE field is allowed in CLASS";
+format_error({namelist_redefinition,Name}) ->
+    io_lib:format("the name '~s' can not be redefined", [Name]);
+format_error({param_bad_type, Ref}) ->
+    io_lib:format("'~p' is not a parameterized type", [Ref]);
+format_error(param_wrong_number_of_arguments) ->
+    "wrong number of arguments";
+format_error(reversed_range) ->
+    "ranges must be given in increasing order";
+format_error({syntax_duplicated_fields,Fields}) ->
+    io_lib:format("~s must only occur once in the syntax list",
+		  [format_fields(Fields)]);
+format_error(syntax_nomatch) ->
+    "unexpected end of object definition";
+format_error({syntax_mandatory_in_optional_group,Name}) ->
+    io_lib:format("the field '&~s' must not be within an optional group since it is not optional",
+		  [Name]);
+format_error({syntax_missing_mandatory_fields,Fields}) ->
+    io_lib:format("missing mandatory ~s in the syntax list",
+		  [format_fields(Fields)]);
+format_error({syntax_nomatch,Actual}) ->
+    io_lib:format("~s is not the next item allowed according to the defined syntax",
+		  [Actual]);
+format_error({syntax_undefined_field,Field}) ->
+    io_lib:format("'&~s' is not a field of the class being defined",
+		  [Field]);
 format_error({undefined,Name}) ->
     io_lib:format("'~s' is referenced, but is not defined", [Name]);
+format_error({undefined_export,Ref}) ->
+    io_lib:format("'~s' is exported but is not defined", [Ref]);
+format_error({undefined_field,FieldName}) ->
+    io_lib:format("the field '&~s' is undefined", [FieldName]);
+format_error({undefined_import,Ref,Module}) ->
+    io_lib:format("'~s' is not exported from ~s", [Ref,Module]);
+format_error({unique_and_default,Field}) ->
+    io_lib:format("the field '&~s' must not have both 'UNIQUE' and 'DEFAULT'",
+		  [Field]);
+format_error({value_reused,Val}) ->
+    io_lib:format("the value '~p' is used more than once", [Val]);
+format_error({non_unique_object,Id}) ->
+    io_lib:format("object set with a UNIQUE field value of '~p' is used more than once", [Id]);
 format_error(Other) ->
     io_lib:format("~p", [Other]).
 
-error({_,{structured_error,_,_,_}=SE,_}) ->
-    SE;
-error({export,Msg,#state{mname=Mname,type=Ref,tname=Typename}}) ->
-    Pos = Ref#'Externaltypereference'.pos,
-    io:format("asn1error:~p:~p:~p~n~p~n",[Pos,Mname,Typename,Msg]),
-    {error,{export,Pos,Mname,Typename,Msg}};
-error({import,Msg,#state{mname=Mname,type=Ref,tname=Typename}}) ->
-    PosOfDef =
-	fun(#'Externaltypereference'{pos=P}) -> P;
-	   (#'Externalvaluereference'{pos=P}) -> P
-	end,
-    Pos = PosOfDef(Ref),
-    io:format("asn1error:~p:~p:~p~n~p~n",[Pos,Mname,Typename,Msg]),
-    {error,{import,Pos,Mname,Typename,Msg}};
-% error({type,{Msg1,Msg2},#state{mname=Mname,type=Type,tname=Typename}}) 
-%   when is_record(Type,typedef) ->
-%     io:format("asn1error:~p:~p:~p ~p~n",
-% 	      [Type#typedef.pos,Mname,Typename,Msg1]),
-%     {error,{type,Type#typedef.pos,Mname,Typename,Msg1,Msg2}};
-error({type,Msg,#state{mname=Mname,type=Type,tname=Typename}}) 
-  when is_record(Type,type) ->
-    io:format("asn1error:~p:~p~n~p~n",
-	      [Mname,Typename,Msg]),
-    {error,{type,Mname,Typename,Msg}};
-error({type,Msg,#state{mname=Mname,type=Type,tname=Typename}}) 
-  when is_record(Type,typedef) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",
-	      [Type#typedef.pos,Mname,Typename,Msg]),
-    {error,{type,Type#typedef.pos,Mname,Typename,Msg}};
-error({type,Msg,#state{mname=Mname,type=Type,tname=Typename}}) 
-  when is_record(Type,ptypedef) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",
-	      [Type#ptypedef.pos,Mname,Typename,Msg]),
-    {error,{type,Type#ptypedef.pos,Mname,Typename,Msg}};
-error({type,Msg,#state{mname=Mname,value=Value,vname=Valuename}})
-  when is_record(Value,valuedef) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",[Value#valuedef.pos,Mname,Valuename,Msg]),
-    {error,{type,Value#valuedef.pos,Mname,Valuename,Msg}};
-error({type,Msg,#state{mname=Mname,type=Type,tname=Typename}}) 
-  when is_record(Type,pobjectdef) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",
-	      [Type#pobjectdef.pos,Mname,Typename,Msg]),
-    {error,{type,Type#pobjectdef.pos,Mname,Typename,Msg}};
-error({value,Msg,#state{mname=Mname,value=Value,vname=Valuename}}) 
-  when is_record(Value,valuedef) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",[Value#valuedef.pos,Mname,Valuename,Msg]),
-    {error,{value,Value#valuedef.pos,Mname,Valuename,Msg}};
-error({Other,Msg,#state{mname=Mname,value=#valuedef{pos=Pos},vname=Valuename}}) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",[Pos,Mname,Valuename,Msg]),
-    {error,{Other,Pos,Mname,Valuename,Msg}};
-error({Other,Msg,#state{mname=Mname,type=#typedef{pos=Pos},tname=Typename}}) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",[Pos,Mname,Typename,Msg]),
-    {error,{Other,Pos,Mname,Typename,Msg}};
-error({Other,Msg,#state{mname=Mname,type=#classdef{pos=Pos},tname=Typename}}) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",[Pos,Mname,Typename,Msg]),
-    {error,{Other,Pos,Mname,Typename,Msg}};
-error({Other,Msg,#state{mname=Mname,type=Type,tname=Typename}}) ->
-    io:format("asn1error:~p:~p:~p~n~p~n",[asn1ct:get_pos_of_def(Type),Mname,Typename,Msg]),
-    {error,{Other,asn1ct:get_pos_of_def(Type),Mname,Typename,Msg}}.
+format_fields([F]) ->
+    io_lib:format("field '&~s'", [F]);
+format_fields([H|T]) ->
+    [io_lib:format("fields '&~s'", [H])|
+     [io_lib:format(", '&~s'", [F]) || F <- T]].
+
+format_elements([H1,H2|T]) ->
+    [io_lib:format("~p, ", [H1])|format_elements([H2|T])];
+format_elements([H]) ->
+    io_lib:format("~p", [H]).
 
 include_default_type(Module) ->
     NameAbsList = default_type_list(),
@@ -7093,62 +6043,62 @@ default_type_list() ->
      ].
 
 
-include_default_class(S,Module) ->
-    NameAbsList = default_class_list(S),
-    include_default_class1(Module,NameAbsList).
+include_default_class(S, Module) ->
+    _ = [include_default_class1(S, Module, ClassDef) ||
+	    ClassDef <- default_class_list()],
+	ok.
 
-include_default_class1(_,[]) ->
-    ok;
-include_default_class1(Module,[{Name,TS}|Rest]) ->
-    case asn1_db:dbget(Module,Name) of
+include_default_class1(S, Module, {Name,Ts0}) ->
+    case asn1_db:dbget(Module, Name) of
 	undefined ->
-	    C = #classdef{checked=true,name=Name,
-			  typespec=TS},
-	    asn1_db:dbput(Module,Name,C);
-	_ -> ok
-    end,
-    include_default_class1(Module,Rest).
+	    #objectclass{fields=Fields,
+			 syntax={'WITH SYNTAX',Syntax0}} = Ts0,
+	    Syntax = preprocess_syntax(S, Syntax0, Fields),
+	    Ts = Ts0#objectclass{syntax={preprocessed_syntax,Syntax}},
+	    C = #classdef{checked=true,module=Module,
+			  name=Name,typespec=Ts},
+	    asn1_db:dbput(Module, Name, C);
+	_ ->
+	    ok
+    end.
 
-default_class_list(S) ->
+default_class_list() ->
     [{'TYPE-IDENTIFIER',
-      {objectclass,
-       [{fixedtypevaluefield,
-	 id,
-	 #type{tag=?TAG_PRIMITIVE(?N_OBJECT_IDENTIFIER),
-	       def='OBJECT IDENTIFIER'},
-	 'UNIQUE',
-	 'MANDATORY'},
-	{typefield,'Type','MANDATORY'}],
-       {'WITH SYNTAX',
-	[{typefieldreference,'Type'},
-	 'IDENTIFIED',
-	 'BY',
-	 {valuefieldreference,id}]}}},
+      #objectclass{fields=[{fixedtypevaluefield,
+			    id,
+			    #type{tag=[?TAG_PRIMITIVE(?N_OBJECT_IDENTIFIER)],
+				  def='OBJECT IDENTIFIER'},
+			    'UNIQUE',
+			    'MANDATORY'},
+			   {typefield,'Type','MANDATORY'}],
+		   syntax={'WITH SYNTAX',
+			   [{typefieldreference,'Type'},
+			    'IDENTIFIED',
+			    'BY',
+			    {valuefieldreference,id}]}}},
      {'ABSTRACT-SYNTAX',
-      {objectclass,
-       [{fixedtypevaluefield,
-	 id,
-	 #type{tag=?TAG_PRIMITIVE(?N_OBJECT_IDENTIFIER),
-	       def='OBJECT IDENTIFIER'},
-	 'UNIQUE',
-	 'MANDATORY'},
-	{typefield,'Type','MANDATORY'},
-	{fixedtypevaluefield,
-	 property,
-	 #type{tag=?TAG_PRIMITIVE(?N_BIT_STRING),
-	       def={'BIT STRING',[]}},
-	 undefined,
-	 {'DEFAULT',
-	  [0,1,0]}}],
-       {'WITH SYNTAX',
-	[{typefieldreference,'Type'},
-	 'IDENTIFIED',
-	 'BY',
-	 {valuefieldreference,id},
-	 ['HAS',
-	  'PROPERTY',
-	  {valuefieldreference,property}]]}}}].
-
+      #objectclass{fields=[{fixedtypevaluefield,
+			    id,
+			    #type{tag=[?TAG_PRIMITIVE(?N_OBJECT_IDENTIFIER)],
+				  def='OBJECT IDENTIFIER'},
+			    'UNIQUE',
+			    'MANDATORY'},
+			   {typefield,'Type','MANDATORY'},
+			   {fixedtypevaluefield,
+			    property,
+			    #type{tag=[?TAG_PRIMITIVE(?N_BIT_STRING)],
+				  def={'BIT STRING',[]}},
+			    undefined,
+			    {'DEFAULT',
+			     [0,1,0]}}],
+		   syntax={'WITH SYNTAX',
+			   [{typefieldreference,'Type'},
+			    'IDENTIFIED',
+			    'BY',
+			    {valuefieldreference,id},
+			    ['HAS',
+			     'PROPERTY',
+			     {valuefieldreference,property}]]}}}].
 
 new_reference_name(Name) ->
     case get(asn1_reference) of
@@ -7177,8 +6127,9 @@ insert_once(S,Tab,Key) ->
 	    skipped
     end.
 
-check_fold(S, [H|T], Check) ->
-    Type = asn1_db:dbget(S#state.mname, H),
+check_fold(S0, [H|T], Check) ->
+    Type = asn1_db:dbget(S0#state.mname, H),
+    S = S0#state{error_context=Type},
     case Check(S, H, Type) of
 	ok ->
 	    check_fold(S, T, Check);
@@ -7186,3 +6137,20 @@ check_fold(S, [H|T], Check) ->
 	    [Error|check_fold(S, T, Check)]
     end;
 check_fold(_, [], Check) when is_function(Check, 3) -> [].
+
+error_value(Value) when is_integer(Value) -> Value;
+error_value(Value) when is_atom(Value) -> Value;
+error_value(#type{def=Value}) when is_atom(Value) -> Value;
+error_value(#type{def=Value}) -> error_value(Value);
+error_value(RefOrType) ->
+    try name_of_def(RefOrType) of
+	Name -> Name
+    catch _:_ ->
+	    case get_datastr_name(RefOrType) of
+		undefined -> RefOrType;
+		Name -> Name
+	    end
+    end.
+
+name_of_def(#'Externaltypereference'{type=N}) -> N;
+name_of_def(#'Externalvaluereference'{value=N}) -> N.
diff --git a/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl b/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
index 761faa53c5..325bea5879 100644
--- a/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
+++ b/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2002-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2016. All Rights Reserved.
 %% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %% 
 %% %CopyrightEnd%
 %%
@@ -122,8 +123,8 @@ gen_encode_sequence(Erules,Typename,D) when is_record(D,type) ->
 			    asn1ct_gen:un_hyphen_var(lists:concat(['Obj',
 								   AttrN])),
 			emit([ObjectEncode," = ",nl,
-			     "   ",{asis,ObjSetMod},":'getenc_",ObjSetName,
-			     "'(",{asis,UniqueFieldName},", ",nl]),
+			      "   ",{asis,ObjSetMod},":'getenc_",ObjSetName,
+			      "'("]),
 			ValueMatch = value_match(ValueIndex,
 						 lists:concat(["Cindex",N])),
 			emit([indent(35),ValueMatch,"),",nl]),
@@ -198,7 +199,7 @@ gen_decode_sequence(Erules,Typename,D) when is_record(D,type) ->
     asn1ct_name:new(tlv),
     asn1ct_name:new(v),
 
-    {DecObjInf,UniqueFName,ValueIndex} =
+    {DecObjInf,ValueIndex} =
 	case TableConsInfo of
 	    #simpletableattributes{objectsetname=ObjectSetRef,
 				   c_name=AttrN,
@@ -217,12 +218,12 @@ gen_decode_sequence(Erules,Typename,D) when is_record(D,type) ->
 			%% relation from a component to another components
 			%% subtype component
 			{{AttrN,{deep,ObjectSetRef,UniqueFieldName,ValIndex}},
-			 UniqueFieldName,ValIndex};
+			 ValIndex};
 		    false ->
-			{{AttrN,ObjectSetRef},UniqueFieldName,ValIndex}
+			{{AttrN,ObjectSetRef},ValIndex}
 		end;
 	    _ ->
-		{false,false,false}
+		{false,false}
 	end,
     RecordName = lists:concat([get_record_name_prefix(),
 			       asn1ct_gen:list2rname(Typename)]),
@@ -234,7 +235,7 @@ gen_decode_sequence(Erules,Typename,D) when is_record(D,type) ->
 	    asn1ct_name:new(rb),
 	    emit(["   {'",RecordName,"'}.",nl,nl]);
 	{LeadingAttrTerm,PostponedDecArgs} ->
-	    emit([com,nl,nl]),
+	    emit([nl]),
 	    case {LeadingAttrTerm,PostponedDecArgs} of
 		{[],[]} ->
 		    ok;
@@ -246,7 +247,7 @@ gen_decode_sequence(Erules,Typename,D) when is_record(D,type) ->
 		    {ObjSetMod,ObjSetName} = ObjSetRef,
 		    emit([DecObj," =",nl,
 			  "   ",{asis,ObjSetMod},":'getdec_",ObjSetName,"'(",
-			  {asis,UniqueFName},", ",ValueMatch,"),",nl]),
+			  ValueMatch,"),",nl]),
 		    gen_dec_postponed_decs(DecObj,PostponedDecArgs)
 	    end,
 	    demit(["Result = "]), %dbg
@@ -357,7 +358,7 @@ gen_decode_set(Erules,Typename,D) when is_record(D,type) ->
     asn1ct_name:new(v),
 
 
-    {DecObjInf,UniqueFName,ValueIndex} =
+    {DecObjInf,ValueIndex} =
 	case TableConsInfo of
 %%	    {ObjectSetRef,AttrN,_N,UniqueFieldName} ->%% N is index of attribute that determines constraint
 	    #simpletableattributes{objectsetname=ObjectSetRef,
@@ -378,12 +379,12 @@ gen_decode_set(Erules,Typename,D) when is_record(D,type) ->
 			%% relation from a component to another components
 			%% subtype component
 			{{AttrN,{deep,ObjectSetRef,UniqueFieldName,ValIndex}},
-			 UniqueFieldName,ValIndex};
+			 ValIndex};
 		    false ->
-			{{AttrN,ObjectSetRef},UniqueFieldName,ValIndex}
+			{{AttrN,ObjectSetRef},ValIndex}
 		end;
 	    _ ->
-		{false,false,false}
+		{false,false}
 	end,
 
     case CompList of
@@ -413,7 +414,7 @@ gen_decode_set(Erules,Typename,D) when is_record(D,type) ->
 	    %% return value as record
 	    emit(["   {'",RecordName,"'}.",nl]);
 	{LeadingAttrTerm,PostponedDecArgs} ->
-	    emit([com,nl,nl]),
+	    emit([nl]),
 	    case {LeadingAttrTerm,PostponedDecArgs} of
 		{[],[]} ->
 		    ok;
@@ -425,7 +426,7 @@ gen_decode_set(Erules,Typename,D) when is_record(D,type) ->
 		    {ObjSetMod,ObjSetName} = ObjSetRef,
 		    emit([DecObj," =",nl,
 			  "   ",{asis,ObjSetMod},":'getdec_",ObjSetName,"'(",
-			  {asis,UniqueFName},", ",ValueMatch,"),",nl]),
+			  ValueMatch,"),",nl]),
 		    gen_dec_postponed_decs(DecObj,PostponedDecArgs)
 	    end,
 	    demit(["Result = "]), %dbg
@@ -499,9 +500,7 @@ gen_decode_sof(Erules,TypeName,_InnerTypeName,D) when is_record(D,type) ->
 		   Atom when is_atom(Atom) -> Atom;
 		   _ -> TypeNameSuffix
 	       end,
-    ObjFun = false,
-    gen_dec_line(Erules,TypeName,ContName,[],Cont,mandatory,ObjFun),
-    %%    gen_dec_line_sof(Erules,Typename,ContName,Cont,ObjFun),
+    gen_dec_line(Erules,TypeName,ContName,[],Cont,mandatory),
     emit([" || ",{curr,v}," <- ",{curr,tlv},"].",nl,nl,nl]).
     
 
@@ -577,6 +576,8 @@ gen_decode_choice(Erules,Typename,D) when is_record(D,type) ->
 gen_enc_sequence_call(Erules,TopType,[#'ComponentType'{name=Cname,typespec=Type,prop=Prop,textual_order=Order}|Rest],Pos,Ext,EncObj) ->
     asn1ct_name:new(encBytes),
     asn1ct_name:new(encLen),
+    asn1ct_name:new(tmpBytes),
+    asn1ct_name:new(tmpLen),
     CindexPos =
 	case Order of
 	    undefined ->
@@ -615,18 +616,20 @@ gen_dec_sequence_call1(Erules,TopType,[#'ComponentType'{name=Cname,typespec=Type
     {LA,PostponedDec} = 
 	gen_dec_component(Erules,TopType,Cname,Tags,Type,Num,Prop,
 			  Ext,DecObjInf),
+    emit([com,nl]),
     case Rest of
 	[] ->
 	    {LA ++ LeadingAttrAcc,PostponedDec ++ ArgsAcc};
 	_ ->
-	    emit([com,nl]),
 	    asn1ct_name:new(bytes),
 	    gen_dec_sequence_call1(Erules,TopType,Rest,Num+1,Ext,DecObjInf,
 				   LA++LeadingAttrAcc,PostponedDec++ArgsAcc)
     end;
 
 gen_dec_sequence_call1(_Erules,_TopType,[],1,_,_,_,_) ->
-    no_terms.
+    no_terms;
+gen_dec_sequence_call1(_, _, [], _Num, _, _, LA, PostponedDec) ->
+    {LA, PostponedDec}.
 
 gen_dec_sequence_call2(_Erules,_TopType, {[], [], []}, _Ext,_DecObjInf) ->
     no_terms;
@@ -641,7 +644,6 @@ gen_dec_sequence_call2(Erules,TopType,{Root1,EList,Root2},_Ext,DecObjInf) ->
     %% TagList is the tags of Root2 elements from the first up to and
     %% including the first mandatory element.
     TagList = get_root2_taglist(Root2,[]),
-    emit({com,nl}),
     emit([{curr,tlv}," = ",
 	  {call,ber,skip_ExtensionAdditions,
 	   [{prev,tlv},{asis,TagList}]},com,nl]),
@@ -706,8 +708,6 @@ emit_term_tlv('OPTIONAL',InnerType,DecObjInf) ->
     emit_term_tlv(opt_or_def,InnerType,DecObjInf);
 emit_term_tlv(Prop,{typefield,_},DecObjInf) ->
     emit_term_tlv(Prop,type_or_object_field,DecObjInf);
-emit_term_tlv(Prop,{objectfield,_,_},DecObjInf) ->
-    emit_term_tlv(Prop,type_or_object_field,DecObjInf);
 emit_term_tlv(opt_or_def,type_or_object_field,NotFalse) 
   when NotFalse /= false ->
     asn1ct_name:new(tmpterm),
@@ -789,6 +789,7 @@ gen_enc_choice2(Erules,TopType,[H1|T]) when is_record(H1,'ComponentType') ->
 						      componentrelation)} of
 	    {#'ObjectClassFieldType'{},{componentrelation,_,_}} ->
 		asn1ct_name:new(tmpBytes),
+		asn1ct_name:new(tmpLen),
 		asn1ct_name:new(encBytes),
 		asn1ct_name:new(encLen),
 		Emit = ["{",{curr,tmpBytes},", _} = "],
@@ -866,7 +867,7 @@ gen_dec_choice_cases(Erules,TopType, [H|T]) ->
 			    (?ASN1CT_GEN_BER:decode_class(T1class) bsl 10) +
 			    T1number,",_} -> ",nl]),
 		      emit([indent(8),"{",{asis,Cname},", "]),
-		      gen_dec_line(Erules,TopType,Cname,[],Type,Prop,false),
+		      gen_dec_line(Erules,TopType,Cname,[],Type,Prop),
 		      emit(["};",nl,nl]),
 		      Fun(Tail,Fun);
 		 ([],_) ->
@@ -893,7 +894,7 @@ gen_dec_choice_cases(Erules,TopType, [H|T]) ->
 		  (?ASN1CT_GEN_BER:decode_class(FirstT#tag.class) bsl 10) +
 		  FirstT#tag.number,", ",{curr,v},"} -> ",nl]),
 	    emit([indent(8),"{",{asis,Cname},", "]),
-	    gen_dec_line(Erules,TopType,Cname,[],Type#type{tag=RestT},Prop,false),
+	    gen_dec_line(Erules,TopType,Cname,[],Type#type{tag=RestT},Prop),
 	    emit(["};",nl,nl])
     end,
     gen_dec_choice_cases(Erules,TopType, T).
@@ -929,7 +930,6 @@ gen_enc_line(Erules,TopType,Cname,
   when is_list(Element) ->
     case asn1ct_gen:get_constraint(C,componentrelation) of
 	{componentrelation,_,_} ->
-	    asn1ct_name:new(tmpBytes),
 	    gen_enc_line(Erules,TopType,Cname,Type,Element,Indent,OptOrMand,
 			 ["{",{curr,tmpBytes},",_} = "],EncObj);
 	_ ->
@@ -962,8 +962,7 @@ gen_enc_line(Erules,TopType,Cname,Type,Element,Indent,OptOrMand,Assign,EncObj)
     WhatKind = asn1ct_gen:type(InnerType),
     emit(IndDeep),
     emit(Assign),
-    gen_optormand_case(OptOrMand,Erules,TopType,Cname,Type,InnerType,WhatKind,
-		       Element),
+    gen_optormand_case(OptOrMand, Erules, TopType, Cname, Type, Element),
     case {Type,asn1ct_gen:get_constraint(Type#type.constraint,
 					 componentrelation)} of
 % 	#type{constraint=[{tableconstraint_info,RefedFieldName}],
@@ -991,12 +990,8 @@ gen_enc_line(Erules,TopType,Cname,Type,Element,Indent,OptOrMand,Assign,EncObj)
 				  {call,ber,encode_open_type,
 				   [{curr,tmpBytes},{asis,Tag}]},nl]);
 			_ ->
-			    emit(["{",{next,tmpBytes},",",{curr,tmpLen},
-				  "} = ",
-				  {call,ber,encode_open_type,
-				   [{curr,tmpBytes},{asis,Tag}]},com,nl]),
-			    emit(IndDeep),
-			    emit(["{",{next,tmpBytes},", ",{curr,tmpLen},"}"])
+			    emit([{call,ber,encode_open_type,
+				   [{curr,tmpBytes},{asis,Tag}]}])
 		    end;
 		Err ->
 		    throw({asn1,{'internal error',Err}})
@@ -1033,26 +1028,19 @@ gen_enc_line(Erules,TopType,Cname,Type,Element,Indent,OptOrMand,Assign,EncObj)
 	    emit([nl,indent(7),"end"])
     end.
 
-gen_optormand_case(mandatory,_Erules,_TopType,_Cname,_Type,_InnerType,_WhatKind,
-		   _Element) ->
+gen_optormand_case(mandatory, _Erules, _TopType, _Cname, _Type, _Element) ->
     ok;
-gen_optormand_case('OPTIONAL',Erules,_TopType,_Cname,_Type,_InnerType,_WhatKind,
-		   Element) ->
+gen_optormand_case('OPTIONAL', Erules, _TopType, _Cname, _Type, Element) ->
     emit([" case ",Element," of",nl]),
     emit([indent(9),"asn1_NOVALUE -> {",
 	  empty_lb(Erules),",0};",nl]),
     emit([indent(9),"_ ->",nl,indent(12)]);
-gen_optormand_case({'DEFAULT',DefaultValue},Erules,TopType,Cname,Type,
-		   InnerType,WhatKind,Element) ->
+gen_optormand_case({'DEFAULT',DefaultValue}, Erules, _TopType,
+		   _Cname, Type, Element) ->
     CurrMod = get(currmod),
     case catch lists:member(der,get(encoding_options)) of
 	true ->
-	    emit(" case catch "),
-	    asn1ct_gen:gen_check_call(TopType,Cname,Type,InnerType,
-				      WhatKind,{asis,DefaultValue},
-				      Element),
-	    emit([" of",nl]),
-	    emit([indent(12),"true -> {[],0};",nl]);
+	    asn1ct_gen_check:emit(Type, DefaultValue, Element);
 	_ ->
 	    emit([" case ",Element," of",nl]),
 	    emit([indent(9),"asn1_DEFAULT -> {",
@@ -1067,12 +1055,17 @@ gen_optormand_case({'DEFAULT',DefaultValue},Erules,TopType,Cname,Type,
 		    emit([indent(9),{asis,
 				     DefaultValue}," -> {",
 			  empty_lb(Erules),",0};",nl])
-	    end
-    end,
-    emit([indent(9),"_ ->",nl,indent(12)]).
+	    end,
+	    emit([indent(9),"_ ->",nl,indent(12)])
+    end.
 
-    
+%% Use for SEQUENCE OF and CHOICE.
+gen_dec_line(Erules,TopType,Cname,CTags,Type,OptOrMand) ->
+    %% The matching on the next line is an assertion.
+    {[],[]} = gen_dec_line(Erules,TopType,Cname,CTags,Type,OptOrMand,false),
+    ok.
 
+%% Use for SEQUENCE.
 gen_dec_line(Erules,TopType,Cname,CTags,Type,OptOrMand,DecObjInf)  ->
     BytesVar = asn1ct_gen:mk_var(asn1ct_name:curr(v)),
     Tag = 
@@ -1159,7 +1152,8 @@ gen_dec_line(Erules,TopType,Cname,CTags,Type,OptOrMand,DecObjInf)  ->
 		
 		emit([indent(4),"_ ->",nl]),
 		case OptOrMand of
-		    {'DEFAULT', Def} ->
+		    {'DEFAULT', Def0} ->
+			Def = asn1ct_gen:conform_value(Type, Def0),
 			emit([indent(8),"{",{asis,Def},",",{prev,tlv},"}",nl]);
 		    'OPTIONAL' ->
 			emit([indent(8),"{ asn1_NOVALUE, ",{prev,tlv},"}",nl])
@@ -1213,28 +1207,25 @@ gen_dec_call({typefield,_},_,_,Cname,Type,BytesVar,Tag,_,_,_DecObjInf,OptOrMandC
 	(Type#type.def)#'ObjectClassFieldType'.fieldname,
     [{Cname,RefedFieldName,asn1ct_gen:mk_var(asn1ct_name:curr(term)),
       asn1ct_gen:mk_var(asn1ct_name:curr(tmpterm)),Tag,OptOrMandComp}];
-gen_dec_call({objectfield,PrimFieldName,PFNList},_,_,Cname,_,BytesVar,Tag,_,_,_,OptOrMandComp) ->
-    call(decode_open_type, [BytesVar,{asis,Tag}]),
-    [{Cname,{PrimFieldName,PFNList},asn1ct_gen:mk_var(asn1ct_name:curr(term)),
-      asn1ct_gen:mk_var(asn1ct_name:curr(tmpterm)),Tag,OptOrMandComp}];
-gen_dec_call(InnerType,Erules,TopType,Cname,Type,BytesVar,Tag,PrimOptOrMand,
-	     OptOrMand,DecObjInf,_) ->
+gen_dec_call(InnerType, _Erules, TopType, Cname, Type, BytesVar,
+	     Tag, _PrimOptOrMand, _OptOrMand, DecObjInf,_) ->
     WhatKind = asn1ct_gen:type(InnerType),
-    gen_dec_call1(WhatKind,InnerType,Erules,TopType,Cname,Type,BytesVar,Tag,
-		  PrimOptOrMand,OptOrMand),
+    gen_dec_call1(WhatKind, InnerType, TopType, Cname,
+		  Type, BytesVar, Tag),
     case DecObjInf of
-	{Cname,{_,OSet,UniqueFName,ValIndex}} ->
+	{Cname,{_,OSet,_UniqueFName,ValIndex}} ->
 	    Term = asn1ct_gen:mk_var(asn1ct_name:curr(term)),
 	    ValueMatch = value_match(ValIndex,Term),
 	    {ObjSetMod,ObjSetName} = OSet,
 	    emit([",",nl,"ObjFun = ",{asis,ObjSetMod},":'getdec_",ObjSetName,
-		  "'(",{asis,UniqueFName},", ",ValueMatch,")"]);
+		  "'(",ValueMatch,")"]);
 	_ ->
 	    ok
     end,
     [].
-gen_dec_call1({primitive,bif},InnerType,Erules,TopType,Cname,Type,BytesVar,
-	      Tag,OptOrMand,_) ->
+
+gen_dec_call1({primitive,bif}, InnerType, TopType, Cname,
+	      Type, BytesVar, Tag) ->
     case {asn1ct:get_gen_state_field(namelist),InnerType} of
 	{[{Cname,undecoded}|Rest],_} ->
 	    asn1ct:add_generated_refed_func({[Cname|TopType],undecoded,
@@ -1243,11 +1234,10 @@ gen_dec_call1({primitive,bif},InnerType,Erules,TopType,Cname,Type,BytesVar,
 	    emit(["{'",asn1ct_gen:list2name([Cname|TopType]),"',",
 		  BytesVar,"}"]);
 	_ ->
-	    ?ASN1CT_GEN_BER:gen_dec_prim(Erules,Type,BytesVar,Tag,[],
-					?PRIMITIVE,OptOrMand)
+	    ?ASN1CT_GEN_BER:gen_dec_prim(Type, BytesVar, Tag)
     end;
-gen_dec_call1('ASN1_OPEN_TYPE',_InnerType,Erules,TopType,Cname,Type,BytesVar,
-	      Tag,OptOrMand,_) ->
+gen_dec_call1('ASN1_OPEN_TYPE', _InnerType, TopType, Cname,
+	      Type, BytesVar, Tag) ->
     case {asn1ct:get_gen_state_field(namelist),Type#type.def} of
 	{[{Cname,undecoded}|Rest],_} ->
 	    asn1ct:add_generated_refed_func({[Cname|TopType],undecoded,
@@ -1256,15 +1246,12 @@ gen_dec_call1('ASN1_OPEN_TYPE',_InnerType,Erules,TopType,Cname,Type,BytesVar,
 	    emit(["{'",asn1ct_gen:list2name([Cname|TopType]),"',",
 		  BytesVar,"}"]);
 	{_,#'ObjectClassFieldType'{type=OpenType}} ->
-	    ?ASN1CT_GEN_BER:gen_dec_prim(Erules,#type{def=OpenType},
-					 BytesVar,Tag,[],
-					 ?PRIMITIVE,OptOrMand);
+	    ?ASN1CT_GEN_BER:gen_dec_prim(#type{def=OpenType},
+					 BytesVar, Tag);
 	_ ->
-	    ?ASN1CT_GEN_BER:gen_dec_prim(Erules,Type,BytesVar,Tag,[],
-					 ?PRIMITIVE,OptOrMand)
+	    ?ASN1CT_GEN_BER:gen_dec_prim(Type, BytesVar, Tag)
     end;
-gen_dec_call1(WhatKind,_,_Erules,TopType,Cname,Type,BytesVar,
-	      Tag,_,_OptOrMand) ->
+gen_dec_call1(WhatKind, _, TopType, Cname, Type, BytesVar, Tag) ->
     case asn1ct:get_gen_state_field(namelist) of
 	[{Cname,undecoded}|Rest] ->
 	    asn1ct:add_generated_refed_func({[Cname|TopType],undecoded,
diff --git a/lib/asn1/src/asn1ct_constructed_per.erl b/lib/asn1/src/asn1ct_constructed_per.erl
index d279e9697f..a34b25182c 100644
--- a/lib/asn1/src/asn1ct_constructed_per.erl
+++ b/lib/asn1/src/asn1ct_constructed_per.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -43,10 +44,13 @@ gen_encode_set(Erules,TypeName,D) ->
 gen_encode_sequence(Erules,TypeName,D) ->
     gen_encode_constructed(Erules,TypeName,D).
 
-gen_encode_constructed(Erule,Typename,D) when is_record(D,type) ->
+gen_encode_constructed(Erule, Typename, #type{}=D) ->
     asn1ct_name:start(),
-    asn1ct_name:new(term),
-    asn1ct_name:new(bytes),
+    Imm = gen_encode_constructed_imm(Erule, Typename, D),
+    asn1ct_imm:enc_cg(Imm, is_aligned(Erule)),
+    emit([".",nl]).
+
+gen_encode_constructed_imm(Erule, Typename, #type{}=D) ->
     {ExtAddGroup,TmpCompList,TableConsInfo} =
 	case D#type.def of
 	    #'SEQUENCE'{tablecinf=TCI,components=CL,extaddgroup=ExtAddGroup0} ->
@@ -65,74 +69,36 @@ gen_encode_constructed(Erule,Typename,D) when is_record(D,type) ->
 		       [Comp#'ComponentType'{textual_order=undefined}||
 			   Comp<-TmpCompList]
 	       end,
-    case Typename of
-	['EXTERNAL'] ->
-	    emit([{next,val}," = ",
-		  {call,ext,transform_to_EXTERNAL1990,
-		   [{curr,val}]},com,nl]),
-	    asn1ct_name:new(val);
-	_ ->
-	    ok
-    end,
-    case {Optionals = optionals(to_textual_order(CompList)),CompList,
-	  is_optimized(Erule)} of
-	{[],EmptyCL,_} when EmptyCL == {[],[],[]};EmptyCL == {[],[]};EmptyCL == [] -> 
-	    ok;
-	{[],_,_} ->
-	    emit([{next,val}," = ",{curr,val},",",nl]);
-	{_,_,true} ->
-	    gen_fixoptionals(Optionals),
-	    FixOpts = param_map(fun(Var) ->
-					{var,Var}
-				end,asn1ct_name:all(fixopt)),
-	    emit({"{",{next,val},",Opt} = {",{curr,val},",[",FixOpts,"]},",nl});
-	{_,_,false} ->
-	    asn1ct_func:need({Erule,fixoptionals,3}),
-	    Fixoptcall = ",Opt} = fixoptionals(",
-	    emit({"{",{next,val},Fixoptcall,
-		  {asis,Optionals},",",length(Optionals),
-		  ",",{curr,val},"),",nl})
-    end,
-    asn1ct_name:new(val),
+    ExternalImm =
+	case Typename of
+	    ['EXTERNAL'] ->
+		Next = asn1ct_gen:mk_var(asn1ct_name:next(val)),
+		Curr = asn1ct_gen:mk_var(asn1ct_name:curr(val)),
+		asn1ct_name:new(val),
+		[{call,ext,transform_to_EXTERNAL1990,[{var,Curr}],{var,Next}}];
+	    _ ->
+		[]
+	end,
+    Aligned = is_aligned(Erule),
+    Value0 = make_var(val),
+    Optionals = optionals(to_textual_order(CompList)),
+    ImmOptionals = [asn1ct_imm:per_enc_optional(Value0, Opt, Aligned) ||
+		       Opt <- Optionals],
     Ext = extensible_enc(CompList),
-    case Ext of
-	{ext,_,NumExt} when NumExt > 0 ->
-	    case extgroup_pos_and_length(CompList) of
-		{extgrouppos,[]} -> % no extenstionAdditionGroup
-		    ok;
-		{extgrouppos,ExtGroupPosLenList} ->
-		    ExtGroupFun = 
-			fun({ExtActualGroupPos,ExtGroupVirtualPos,ExtGroupLen}) ->
-				Elements = 
-				    make_elements(ExtGroupVirtualPos+1,
-						  "Val1",
-						  lists:seq(1,ExtGroupLen)),
-				emit([
-				      {next,val}," = case [X || X <- [",Elements,
-				      "],X =/= asn1_NOVALUE] of",nl,
-				      "[] -> setelement(",
-				      {asis,ExtActualGroupPos+1},",",
-				      {curr,val},",",
-				      "asn1_NOVALUE);",nl,
-				      "_ -> setelement(",{asis,ExtActualGroupPos+1},",",
-				      {curr,val},",",
-				      "{extaddgroup,", Elements,"})",nl,
-				      "end,",nl]),
-				asn1ct_name:new(val)
-			end,
-		    lists:foreach(ExtGroupFun,ExtGroupPosLenList)
-	    end,
-	    asn1ct_name:new(tmpval),
-	    emit(["Extensions = ",
-		  {call,Erule,fixextensions,[{asis,Ext},{curr,val}]},
-		  com,nl]);
-	_ -> true
-    end,
-    EncObj =
+    ExtImm = case Ext of
+		 {ext,ExtPos,NumExt} when NumExt > 0 ->
+		     gen_encode_extaddgroup(CompList),
+		     Value = make_var(val),
+		     asn1ct_imm:per_enc_extensions(Value, ExtPos,
+						   NumExt, Aligned);
+		 _ ->
+		     []
+	     end,
+    {EncObj,ObjSetImm} =
 	case TableConsInfo of
 	    #simpletableattributes{usedclassfield=Used,
 				   uniqueclassfield=Unique} when Used /= Unique ->
-		false;
+		{false,[]};
 	    %% ObjectSet, name of the object set in constraints
 	    %% 
 	    %%{ObjectSet,AttrN,N,UniqueFieldName} -> %% N is index of attribute that determines constraint
@@ -141,24 +107,19 @@ gen_encode_constructed(Erule,Typename,D) when is_record(D,type) ->
 				   c_index=N,
 				   usedclassfield=UniqueFieldName,
 				   uniqueclassfield=UniqueFieldName,
-				   valueindex=ValueIndex
+				   valueindex=ValueIndex0
 				  } -> %% N is index of attribute that determines constraint
 		{Module,ObjSetName} = ObjectSet,
 		#typedef{typespec=#'ObjectSet'{gen=Gen}} =
 		    asn1_db:dbget(Module, ObjSetName),
 		case Gen of
 		    true ->
-			ObjectEncode = 
-			    asn1ct_gen:un_hyphen_var(lists:concat(['Obj',AttrN])),
-			El = make_element(N+1, asn1ct_gen:mk_var(asn1ct_name:curr(val))),
-			ValueMatch = value_match(ValueIndex, El),
-			emit([ObjectEncode," =",nl,
-			      "  ",{asis,Module},":'getenc_",ObjSetName,"'(",
-			      {asis,UniqueFieldName},", ",nl,
-			      "  ",ValueMatch,"),",nl]),
-			{AttrN,ObjectEncode};
+			ValueIndex = ValueIndex0 ++ [{N+1,top}],
+			Val = make_var(val),
+			{ObjSetImm0,Dst} = enc_dig_out_value(ValueIndex, Val),
+			{{AttrN,Dst},ObjSetImm0};
 		    false ->
-			false
+			{false,[]}
 		end;
 	    _  ->
 		case D#type.tablecinf of
@@ -166,34 +127,52 @@ gen_encode_constructed(Erule,Typename,D) when is_record(D,type) ->
 			%% when the simpletableattributes was at an outer
 			%% level and the objfun has been passed through the
 			%% function call
-			{"got objfun through args","ObjFun"};
+			{{"got objfun through args",{var,"ObjFun"}},[]};
 		    _ ->
-			false
+			{false,[]}
 		end
 	end,
-    emit({"[",nl}),
-    MaybeComma1 = 
+    ImmSetExt =
 	case Ext of
-	    {ext,_Pos,NumExt2} when NumExt2 > 0 -> 
-		call(Erule, setext, ["Extensions =/= []"]),
-		", ";
-	    {ext,_Pos,_} -> 
-		call(Erule, setext, ["false"]),
-		", ";
-	    _ -> 
-		""
-	end,
-    MaybeComma2 = 
-	case optionals(CompList) of
-	    [] -> MaybeComma1;
-	    _ -> 
-		emit(MaybeComma1),
-		emit("Opt"),
-		{",",nl}
+	    {ext,_Pos,NumExt2} when NumExt2 > 0 ->
+		asn1ct_imm:per_enc_extension_bit({var,"Extensions"}, Aligned);
+	    {ext,_Pos,_} ->
+		asn1ct_imm:per_enc_extension_bit([], Aligned);
+	    _ ->
+		[]
 	end,
-    gen_enc_components_call(Erule,Typename,CompList,MaybeComma2,EncObj,Ext),
-    emit({"].",nl}).
+    ImmBody = gen_enc_components_call(Erule, Typename, CompList, EncObj, Ext),
+    ExternalImm ++ ExtImm ++ ObjSetImm ++
+	asn1ct_imm:enc_append([ImmSetExt] ++ ImmOptionals ++ ImmBody).
+
+gen_encode_extaddgroup(CompList) ->
+    case extgroup_pos_and_length(CompList) of
+	{extgrouppos,[]} ->
+	    ok;
+	{extgrouppos,ExtGroupPosLenList} ->
+	    _ = [do_gen_encode_extaddgroup(G) || G <- ExtGroupPosLenList],
+	    ok
+    end.
 
+do_gen_encode_extaddgroup({ActualGroupPos,GroupVirtualPos,GroupLen}) ->
+    Val = asn1ct_gen:mk_var(asn1ct_name:curr(val)),
+    Elements = make_elements(GroupVirtualPos+1,
+			     Val,
+			     lists:seq(1, GroupLen)),
+    Expr = any_non_value(GroupVirtualPos+1, Val, GroupLen, ""),
+    emit([{next,val}," = case ",Expr," of",nl,
+	  "false -> setelement(",{asis,ActualGroupPos+1},", ",
+	  {curr,val},", asn1_NOVALUE);",nl,
+	  "true -> setelement(",{asis,ActualGroupPos+1},", ",
+	  {curr,val},", {extaddgroup,", Elements,"})",nl,
+	  "end,",nl]),
+    asn1ct_name:new(val).
+
+any_non_value(_, _, 0, _) ->
+    [];
+any_non_value(Pos, Val, N, Sep) ->
+    Sep ++ [make_element(Pos, Val)," =/= asn1_NOVALUE"] ++
+	any_non_value(Pos+1, Val, N-1, [" orelse",nl]).
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% generate decode function for SEQUENCE and SET
@@ -328,28 +307,29 @@ gen_dec_constructed_imm(Erule, Typename, #type{}=D) ->
     EmitComp = gen_dec_components_call(Erule, Typename, CompList,
 				       DecObjInf, Ext, length(Optionals)),
     EmitRest = fun({AccTerm,AccBytes}) ->
-		       gen_dec_constructed_imm_2(Typename, CompList,
+		       gen_dec_constructed_imm_2(Erule, Typename,
+						 CompList,
 						 ObjSetInfo,
 						 AccTerm, AccBytes)
 	       end,
     [EmitExt,EmitOpt|EmitComp++[{safe,EmitRest}]].
 
-gen_dec_constructed_imm_2(Typename, CompList,
+gen_dec_constructed_imm_2(Erule, Typename, CompList,
 			  ObjSetInfo, AccTerm, AccBytes) ->
-    {_,UniqueFName,ValueIndex} = ObjSetInfo,
+    {_,_UniqueFName,ValueIndex} = ObjSetInfo,
     case {AccTerm,AccBytes} of
 	{[],[]} ->
 	    ok;
 	{_,[]} ->
 	    ok;
 	{[{ObjSet,LeadingAttr,Term}],ListOfOpenTypes} ->
-	    DecObj = asn1ct_gen:un_hyphen_var(lists:concat(['DecObj',LeadingAttr,Term])),
-	    ValueMatch = value_match(ValueIndex,Term),
-	    {ObjSetMod,ObjSetName} = ObjSet,
-	    emit([DecObj," =",nl,
-		  "   ",{asis,ObjSetMod},":'getdec_",ObjSetName,"'(",
-		  {asis,UniqueFName},", ",ValueMatch,"),",nl]),
-	    gen_dec_listofopentypes(DecObj,ListOfOpenTypes,false)
+	    ValueMatch = value_match(ValueIndex, Term),
+	    _ = [begin
+		     gen_dec_open_type(Erule, ValueMatch, ObjSet,
+				       LeadingAttr, T),
+		     emit([com,nl])
+		 end || T <- ListOfOpenTypes],
+	    ok
     end,
     %% we don't return named lists any more   Cnames = mkcnamelist(CompList), 
     demit({"Result = "}), %dbg
@@ -423,67 +403,121 @@ to_textual_order(Cs) when is_list(Cs) ->
 to_textual_order(Cs) ->
     Cs.
 
-gen_dec_listofopentypes(_,[],_) ->
-    emit(nl);
-gen_dec_listofopentypes(DecObj,[{_Cname,{FirstPFN,PFNList},Term,TmpTerm,Prop}|Rest],_Update) ->
+gen_dec_open_type(Erule, Val, {Xmod,Xtype}, LeadingAttr,
+		  {_,{Name,RestFieldNames},Term,TmpTerm,Prop}) ->
+    #typedef{typespec=ObjSet0} = asn1_db:dbget(Xmod, Xtype),
+    #'ObjectSet'{class=Class,set=ObjSet1} = ObjSet0,
+    #'Externaltypereference'{module=ClMod,type=ClType} = Class,
+    #classdef{typespec=ClassDef} = asn1_db:dbget(ClMod, ClType),
+    #objectclass{fields=ClassFields} = ClassDef,
+    Extensible = lists:member('EXTENSIONMARK', ObjSet1),
+    Typename = [Name,ClType],
+    ObjSet = index_object_set(Erule, ClType, Name,
+			      ObjSet1, ClassFields),
+    Key = erlang:md5(term_to_binary({decode,ObjSet,RestFieldNames,
+				     Prop,Extensible})),
+    Gen = fun(_Fd, N) ->
+		  dec_objset_optional(N, Prop),
+		  dec_objset(Erule, N, ObjSet, RestFieldNames, Typename),
+		  dec_objset_default(N, Name, LeadingAttr, Extensible)
+	  end,
+    Prefix = lists:concat(["dec_os_",Name]),
+    F = asn1ct_func:call_gen(Prefix, Key, Gen),
+    emit([Term," = ",{asis,F},"(",TmpTerm,", ",Val,")"]).
 
-    asn1ct_name:new(tmpterm),
-    asn1ct_name:new(reason),
+dec_objset_optional(N, {'DEFAULT',Val}) ->
+    dec_objset_optional_1(N, Val);
+dec_objset_optional(N, 'OPTIONAL') ->
+    dec_objset_optional_1(N, asn1_NOVALUE);
+dec_objset_optional(_N, mandatory) -> ok.
 
-    emit([Term," = ",nl]),
+dec_objset_optional_1(N, Val) ->
+    emit([{asis,N},"(",{asis,Val},", _Id) ->",nl,
+	  {asis,Val},";",nl]).
 
-    N = case Prop of
-	    mandatory -> 0;
-	    'OPTIONAL' ->
-		emit_opt_or_mand_check(asn1_NOVALUE,TmpTerm),
-		6;
-	    {'DEFAULT',Val} ->
-		emit_opt_or_mand_check(Val,TmpTerm),
-		6
-	end,
+dec_objset(_Erule, _N, [], _, _) ->
+    ok;
+dec_objset(Erule, N, [Obj|Objs], RestFields, Cl) ->
+    dec_objset_1(Erule, N, Obj, RestFields, Cl),
+    emit([";",nl]),
+    dec_objset(Erule, N, Objs, RestFields, Cl).
+
+dec_objset_default(N, C, LeadingAttr, false) ->
+    emit([{asis,N},"(Bytes, Id) ->",nl,
+	  "exit({'Type not compatible with table constraint',"
+	  "{{component,",{asis,C},"},"
+	  "{value,Bytes},"
+	  "{unique_name_and_value,",{asis,LeadingAttr},",Id}}}).",nl,nl]);
+dec_objset_default(N, _, _, true) ->
+    emit([{asis,N},"(Bytes, Id) ->",nl|
+	  case asn1ct:use_legacy_types() of
+	      false ->
+		  ["{asn1_OPENTYPE,Bytes}.",nl,nl];
+	      true ->
+		  ["Bytes.",nl,nl]
+	  end]).
+
+dec_objset_1(Erule, N, {Id,Obj}, RestFields, Typename) ->
+    emit([{asis,N},"(Bytes, ",{asis,Id},") ->",nl]),
+    dec_objset_2(Erule, Obj, RestFields, Typename).
+
+dec_objset_2(Erule, Obj, RestFields0, Typename) ->
+    case Obj of
+	#typedef{name={primitive,bif},typespec=Type} ->
+	    Imm = asn1ct_gen_per:gen_dec_imm(Erule, Type),
+	    {Term,_} = asn1ct_imm:dec_slim_cg(Imm, 'Bytes'),
+	    emit([com,nl,Term]);
+	#typedef{name={constructed,bif},typespec=Type}=Def ->
+	    Prefix = "dec_outlined_",
+	    Key = {dec_outlined,Def},
+	    Gen = fun(_Fd, Name) ->
+			  gen_dec_obj(Erule, Name, Typename, Type)
+		  end,
+	    Func = asn1ct_func:call_gen(Prefix, Key, Gen),
+	    emit(["{Term,_} = ",{asis,Func},"(Bytes)",com,nl,
+		  "Term"]);
+	#typedef{name=Type} ->
+	    emit(["{Result,_} = ",{asis,enc_func("dec_", Type)},"(Bytes),",nl,
+		  "Result"]);
+	#'Externaltypereference'{module=Mod,type=Type} ->
+	    emit("{Term,_} = "),
+	    Func = enc_func("dec_", Type),
+	    case get(currmod) of
+		Mod ->
+		    emit([{asis,Func},"(Bytes)"]);
+		_ ->
+		    emit([{asis,Mod},":",{asis,Func},"(Bytes)"])
+	    end,
+	    emit([com,nl,
+		  "Term"]);
+	#'Externalvaluereference'{module=Mod,value=Value} ->
+	    case asn1_db:dbget(Mod, Value) of
+		#typedef{typespec=#'Object'{def=Def}} ->
+		    {object,_,Fields} = Def,
+		    [NextField|RestFields] = RestFields0,
+		    {NextField,Typedef} = lists:keyfind(NextField, 1, Fields),
+		    dec_objset_2(Erule, Typedef, RestFields, Typename)
+	    end
+    end.
 
-    emit([indent(N+3),"case (catch ",DecObj,"(",
-	  {asis,FirstPFN},", ",TmpTerm,", telltype,",{asis,PFNList},")) of",nl]),
-    emit([indent(N+6),"{'EXIT', ",{curr,reason},"} ->",nl]),
-    emit([indent(N+9),"exit({'Type not compatible with table constraint',",
-	  {curr,reason},"});",nl]),
-    emit([indent(N+6),"{",{curr,tmpterm},",_} ->",nl]),
-    emit([indent(N+9),{curr,tmpterm},nl]),
-
-    case Prop of
-	mandatory ->
-	    emit([indent(N+3),"end,",nl]);
-	_ ->
-	    emit([indent(N+3),"end",nl,
-		  indent(3),"end,",nl])
-    end,
-    gen_dec_listofopentypes(DecObj,Rest,true).
-
-
-emit_opt_or_mand_check(Val,Term) ->
-    emit([indent(3),"case ",Term," of",nl,
-	  indent(6),{asis,Val}," ->",{asis,Val},";",nl,
-	  indent(6),"_ ->",nl]).
-
-%% ENCODE GENERATOR FOR THE CHOICE TYPE *******
-%% assume Val = {Alternative,AltType}
-%% generate
-%%[
-%% ?RT_PER:set_choice(element(1,Val),Altnum,Altlist,ext),
-%%case element(1,Val) of
-%%    alt1 ->
-%%	encode_alt1(element(2,Val));
-%%    alt2 ->
-%%	encode_alt2(element(2,Val))
-%%end
-%%].
-
-gen_encode_choice(Erule,Typename,D) when is_record(D,type) ->
-    {'CHOICE',CompList} = D#type.def,
-    emit({"[",nl}),
+gen_dec_obj(Erules, Name, Typename, Type) ->
+    emit([{asis,Name},"(Bytes) ->",nl]),
+    InnerType = asn1ct_gen:get_inner(Type#type.def),
+    asn1ct_gen:gen_decode_constructed(Erules, Typename,
+				      InnerType, Type).
+
+gen_encode_choice(Erule, TopType, D) ->
+    asn1ct_name:start(),
+    Imm = gen_encode_choice_imm(Erule, TopType, D),
+    asn1ct_imm:enc_cg(Imm, is_aligned(Erule)),
+    emit([".",nl]).
+
+gen_encode_choice_imm(Erule, TopType, #type{def={'CHOICE',CompList}}) ->
     Ext = extensible_enc(CompList),
-    gen_enc_choice(Erule,Typename,CompList,Ext),
-    emit({nl,"].",nl}).
+    Aligned = is_aligned(Erule),
+    Cs = gen_enc_choice(Erule, TopType, CompList, Ext),
+    [{assign,{expr,"{ChoiceTag,ChoiceVal}"},"Val"}|
+     asn1ct_imm:per_enc_choice({var,"ChoiceTag"}, Cs, Aligned)].
 
 gen_decode_choice(Erules,Typename,D) when is_record(D,type) ->
     asn1ct_name:start(),
@@ -496,72 +530,50 @@ gen_decode_choice(Erules,Typename,D) when is_record(D,type) ->
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % Encode generator for SEQUENCE OF type
 
-
-gen_encode_sof(Erule,Typename,SeqOrSetOf,D) when is_record(D,type) ->
+gen_encode_sof(Erule, Typename, SeqOrSetOf, D) ->
     asn1ct_name:start(),
-    {_SeqOrSetOf,ComponentType} = D#type.def,
-    emit({"[",nl}),
-    SizeConstraint = asn1ct_imm:effective_constraint(bitstring,
-						     D#type.constraint),
-    ObjFun =
-	case D#type.tablecinf of
-	    [{objfun,_}|_R] ->
-		", ObjFun";
-	    _->
-		""
-	end,
-    gen_encode_length(Erule, SizeConstraint),
-    emit({indent(3),"'enc_",asn1ct_gen:list2name(Typename),
-	      "_components'(Val",ObjFun,", [])"}),
-    emit({nl,"].",nl}),
-    gen_encode_sof_components(Erule, Typename, SeqOrSetOf, ComponentType).
-
-
-%% Logic copied from asn1_per_bin_rt2ct:encode_constrained_number
-gen_encode_length(per, {Lb,Ub}) when Ub =< 65535, Lb >= 0 ->
-    Range = Ub - Lb + 1,
-    V2 = ["(length(Val) - ",Lb,")"],
-    Encode = if
-		 Range  == 1 ->
-		     "[]";
-		 Range  == 2 ->
-		     {"[",V2,"]"};
-		 Range  =< 4 ->
-		     {"[10,2,",V2,"]"};
-		 Range  =< 8 ->
-		     {"[10,3,",V2,"]"};
-		 Range  =< 16 ->
-		     {"[10,4,",V2,"]"};
-		 Range  =< 32 ->
-		     {"[10,5,",V2,"]"};
-		 Range  =< 64 ->
-		     {"[10,6,",V2,"]"};
-		 Range  =< 128 ->
-		     {"[10,7,",V2,"]"};
-		 Range  =< 255 ->
-		     {"[10,8,",V2,"]"};
-		 Range  =< 256 ->
-		     {"[20,1,",V2,"]"};
-		 Range  =< 65536 ->
-		     {"[20,2,<<",V2,":16>>]"};
-		 true ->
-		     {call,per,encode_length,
-		      [{asis,{Lb,Ub}},"length(Val)"]}
-	     end,
-    emit({nl,Encode,",",nl});
-gen_encode_length(Erules, SizeConstraint) ->
-    emit([nl,indent(3),
-	  case SizeConstraint of
-	      no ->
-		  {call,Erules,encode_length,["length(Val)"]};
-	      _ ->
-		  {call,Erules,encode_length,
-		   [{asis,SizeConstraint},"length(Val)"]}
-	  end,
-	  com,nl]).
+    Imm = gen_encode_sof_imm(Erule, Typename, SeqOrSetOf, D),
+    asn1ct_imm:enc_cg(Imm, is_aligned(Erule)),
+    emit([".",nl,nl]).
 
-gen_decode_sof(Erules,Typename,SeqOrSetOf,D) when is_record(D,type) ->
+gen_encode_sof_imm(Erule, Typename, SeqOrSetOf, #type{}=D) ->
+    {_SeqOrSetOf,ComponentType} = D#type.def,
+    Aligned = is_aligned(Erule),
+    CompType = ComponentType#type.def,
+    Constructed_Suffix = asn1ct_gen:constructed_suffix(SeqOrSetOf, CompType),
+    Conttype = asn1ct_gen:get_inner(CompType),
+    Currmod = get(currmod),
+    Imm0 = case asn1ct_gen:type(Conttype) of
+	       {primitive,bif} ->
+		   asn1ct_gen_per:gen_encode_prim_imm({var,"Comp"},
+						      ComponentType, Aligned);
+	       {constructed,bif} ->
+		   TypeName = [Constructed_Suffix|Typename],
+		   Enc = enc_func(asn1ct_gen:list2name(TypeName)),
+		   ObjArg = case D#type.tablecinf of
+				[{objfun,_}|_] -> [{var,"ObjFun"}];
+				_ -> []
+			    end,
+		   [{apply,{local,Enc,CompType},
+		     [{var,"Comp"}|ObjArg]}];
+	       #'Externaltypereference'{module=Currmod,type=Ename} ->
+		   [{apply,{local,enc_func(Ename),CompType},[{var,"Comp"}]}];
+	       #'Externaltypereference'{module=EMod,type=Ename} ->
+		   [{apply,{EMod,enc_func(Ename),CompType},[{var,"Comp"}]}];
+	       'ASN1_OPEN_TYPE' ->
+		   asn1ct_gen_per:gen_encode_prim_imm({var,"Comp"},
+						      #type{def='ASN1_OPEN_TYPE'},
+						      Aligned)
+	   end,
+    asn1ct_imm:per_enc_sof({var,"Val"}, D#type.constraint, 'Comp',
+			   Imm0, Aligned).
+
+gen_decode_sof(Erules, Typename, SeqOrSetOf, #type{}=D) ->
     asn1ct_name:start(),
+    do_gen_decode_sof(Erules, Typename, SeqOrSetOf, D),
+    emit([".",nl,nl]).
+
+do_gen_decode_sof(Erules, Typename, SeqOrSetOf, D) ->
     {_SeqOrSetOf,ComponentType} = D#type.def,
     SizeConstraint = asn1ct_imm:effective_constraint(bitstring,
 						     D#type.constraint),
@@ -573,10 +585,15 @@ gen_decode_sof(Erules,Typename,SeqOrSetOf,D) when is_record(D,type) ->
 		""
 	end,
     {Num,Buf} = gen_decode_length(SizeConstraint, Erules),
+    Key = erlang:md5(term_to_binary({Typename,SeqOrSetOf,ComponentType})),
+    Gen = fun(_Fd, Name) ->
+		  gen_decode_sof_components(Erules, Name,
+					    Typename, SeqOrSetOf,
+					    ComponentType)
+	  end,
+    F = asn1ct_func:call_gen("dec_components", Key, Gen),
     emit([",",nl,
-	  "'dec_",asn1ct_gen:list2name(Typename),
-	  "_components'(",Num,", ",Buf,ObjFun,", []).",nl,nl]),
-    gen_decode_sof_components(Erules, Typename, SeqOrSetOf, ComponentType).
+	  {asis,F},"(",Num,", ",Buf,ObjFun,", [])"]).
 
 is_aligned(per) -> true;
 is_aligned(uper) -> false.
@@ -586,7 +603,7 @@ gen_decode_length(Constraint, Erule) ->
     Imm = asn1ct_imm:per_dec_length(Constraint, true, is_aligned(Erule)),
     asn1ct_imm:dec_slim_cg(Imm, "Bytes").
 
-gen_encode_sof_components(Erule,Typename,SeqOrSetOf,Cont) ->
+gen_decode_sof_components(Erule, Name, Typename, SeqOrSetOf, Cont) ->
     {ObjFun,ObjFun_Var} =
 	case Cont#type.tablecinf of
 	    [{objfun,_}|_R] ->
@@ -594,76 +611,32 @@ gen_encode_sof_components(Erule,Typename,SeqOrSetOf,Cont) ->
 	    _ ->
 		{"",""}
 	end,
-    emit({"'enc_",asn1ct_gen:list2name(Typename),"_components'([]",
-	  ObjFun_Var,", Acc) -> lists:reverse(Acc);",nl,nl}),
-    emit({"'enc_",asn1ct_gen:list2name(Typename),"_components'([H|T]",
-	  ObjFun,", Acc) ->",nl}),
-    emit({"'enc_",asn1ct_gen:list2name(Typename),"_components'(T"}), 
-    emit({ObjFun,", ["}),
-    %% the component encoder
+    emit([{asis,Name},"(0, Bytes",ObjFun_Var,", Acc) ->",nl,
+	  "{lists:reverse(Acc),Bytes};",nl]),
+    emit([{asis,Name},"(Num, Bytes",ObjFun,", Acc) ->",nl,
+	  "{Term,Remain} = "]),
     Constructed_Suffix = asn1ct_gen:constructed_suffix(SeqOrSetOf,
 						       Cont#type.def),
-    
     Conttype = asn1ct_gen:get_inner(Cont#type.def),
-    Currmod = get(currmod),
-    case asn1ct_gen:type(Conttype) of
-	{primitive,bif} ->
-	    asn1ct_gen_per:gen_encode_prim(Erule, Cont, "H");
-	{constructed,bif} ->
-	    NewTypename = [Constructed_Suffix|Typename],
-	    emit({"'enc_",asn1ct_gen:list2name(NewTypename),"'(H",
-		  ObjFun,")",nl,nl});
-	#'Externaltypereference'{module=Currmod,type=Ename} ->
-	    emit({"'enc_",Ename,"'(H)",nl,nl});
-	#'Externaltypereference'{module=EMod,type=EType} ->
-	    emit({"'",EMod,"':'enc_",EType,"'(H)",nl,nl});
-	'ASN1_OPEN_TYPE' ->
-	    asn1ct_gen_per:gen_encode_prim(Erule,
-					   #type{def='ASN1_OPEN_TYPE'},
-					   "H");
-	_ ->
-	    emit({"'enc_",Conttype,"'(H)",nl,nl})
-    end,
-    emit({" | Acc]).",nl}).
-
-gen_decode_sof_components(Erule,Typename,SeqOrSetOf,Cont) ->
-    {ObjFun,ObjFun_Var} =
-	case Cont#type.tablecinf of
-	    [{objfun,_}|_R] ->
-		{", ObjFun",", _"};
-	    _ ->
-		{"",""}
-	end,
-    emit({"'dec_",asn1ct_gen:list2name(Typename),
-	  "_components'(0, Bytes",ObjFun_Var,", Acc) ->",nl,
-	  indent(3),"{lists:reverse(Acc), Bytes};",nl}),
-    emit({"'dec_",asn1ct_gen:list2name(Typename),
-	  "_components'(Num, Bytes",ObjFun,", Acc) ->",nl}),
-    emit({indent(3),"{Term,Remain} = "}),
-    Constructed_Suffix = asn1ct_gen:constructed_suffix(SeqOrSetOf,
-						       Cont#type.def),
-    Conttype = asn1ct_gen:get_inner(Cont#type.def),
-    Ctgenmod = asn1ct_gen:ct_gen_module(Erule),
     case asn1ct_gen:type(Conttype) of
 	{primitive,bif} ->
-	    Ctgenmod:gen_dec_prim(Erule,Cont,"Bytes"),
+	    asn1ct_gen_per:gen_dec_prim(Erule, Cont, "Bytes"),
 	    emit({com,nl});
 	{constructed,bif} ->
 	    NewTypename = [Constructed_Suffix|Typename],
 	    emit({"'dec_",asn1ct_gen:list2name(NewTypename),
-		  "'(Bytes, telltype",ObjFun,"),",nl});
+		  "'(Bytes",ObjFun,"),",nl});
 	#'Externaltypereference'{}=Etype ->
 	    asn1ct_gen_per:gen_dec_external(Etype, "Bytes"),
 	    emit([com,nl]);
 	'ASN1_OPEN_TYPE' ->
-	    Ctgenmod:gen_dec_prim(Erule,#type{def='ASN1_OPEN_TYPE'},
-				  "Bytes"),
+	    asn1ct_gen_per:gen_dec_prim(Erule, #type{def='ASN1_OPEN_TYPE'},
+					"Bytes"),
 	    emit({com,nl});
 	_ ->
-	    emit({"'dec_",Conttype,"'(Bytes,telltype),",nl})
+	    emit({"'dec_",Conttype,"'(Bytes),",nl})
     end,
-    emit({indent(3),"'dec_",asn1ct_gen:list2name(Typename),
-	  "_components'(Num-1, Remain",ObjFun,", [Term|Acc]).",nl}).
+    emit([{asis,Name},"(Num-1, Remain",ObjFun,", [Term|Acc]).",nl]).
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -754,27 +727,6 @@ gen_dec_optionals(Optionals) ->
     end,
     {imm,Imm0,E}.
 
-gen_fixoptionals([{Pos,Def}|R]) ->
-    asn1ct_name:new(fixopt),
-    emit({{curr,fixopt}," = case element(",{asis,Pos},",",{curr,val},") of",nl,
-	  "asn1_DEFAULT -> 0;",nl,
-	  {asis,Def}," -> 0;",nl,
-	  "_ -> 1",nl,
-	  "end,",nl}),
-    gen_fixoptionals(R);
-gen_fixoptionals([Pos|R]) ->
-    gen_fixoptionals([{Pos,asn1_NOVALUE}|R]);
-gen_fixoptionals([]) ->
-    ok.
-
-    
-param_map(Fun, [H]) ->
-    [Fun(H)];
-param_map(Fun, [H|T]) ->
-    [Fun(H),","|param_map(Fun,T)].
-
-    
-
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% Produce a list with positions (in the Value record) where
 %% there are optional components, start with 2 because first element
@@ -788,15 +740,15 @@ optionals({L1,Ext,L2}) ->
 optionals({L,_Ext}) -> optionals(L,[],2); 
 optionals(L) -> optionals(L,[],2).
 
-optionals([{'EXTENSIONMARK',_,_}|Rest],Acc,Pos) ->
-    optionals(Rest,Acc,Pos); % optionals in extension are currently not handled
-optionals([#'ComponentType'{prop='OPTIONAL'}|Rest],Acc,Pos) ->
-		 optionals(Rest,[Pos|Acc],Pos+1);
-optionals([#'ComponentType'{prop={'DEFAULT',Val}}|Rest],Acc,Pos) ->
-		 optionals(Rest,[{Pos,Val}|Acc],Pos+1);
-optionals([#'ComponentType'{}|Rest],Acc,Pos) ->
-		 optionals(Rest,Acc,Pos+1);
-optionals([],Acc,_) ->
+optionals([#'ComponentType'{prop='OPTIONAL'}|Rest], Acc, Pos) ->
+    optionals(Rest, [Pos|Acc], Pos+1);
+optionals([#'ComponentType'{typespec=T,prop={'DEFAULT',Val}}|Rest],
+	  Acc, Pos) ->
+    Vals = def_values(T, Val),
+    optionals(Rest, [{Pos,Vals}|Acc], Pos+1);
+optionals([#'ComponentType'{}|Rest], Acc, Pos) ->
+    optionals(Rest, Acc, Pos+1);
+optionals([], Acc, _) ->
     lists:reverse(Acc).
 
 %%%%%%%%%%%%%%%%%%%%%%
@@ -858,33 +810,32 @@ add_textual_order1(Cs,NumIn) ->
 		   end,
 		   NumIn,Cs).
 
-gen_enc_components_call(Erule,TopType,{Root,ExtList},MaybeComma,DynamicEnc,Ext) ->
-    gen_enc_components_call(Erule,TopType,{Root,ExtList,[]},MaybeComma,DynamicEnc,Ext);
-gen_enc_components_call(Erule,TopType,CL={Root,ExtList,Root2},MaybeComma,DynamicEnc,Ext) ->
+gen_enc_components_call(Erule,TopType,{Root,ExtList}, DynamicEnc,Ext) ->
+    gen_enc_components_call(Erule,TopType,{Root,ExtList,[]}, DynamicEnc,Ext);
+gen_enc_components_call(Erule,TopType,CL={Root,ExtList,Root2}, DynamicEnc,Ext) ->
     %% The type has extensionmarker
-    Rpos = gen_enc_components_call1(Erule,TopType,Root++Root2,1,MaybeComma,DynamicEnc,noext),
-    case Ext of
-	{ext,_,ExtNum} when ExtNum > 0 ->
-	    emit([nl,
-		  ",Extensions",nl]);
-
-	_ -> true
-    end,
+    {Imm0,Rpos} = gen_enc_components_call1(Erule,TopType,Root++Root2,1, DynamicEnc,noext,[]),
+    ExtImm = case Ext of
+		 {ext,_,ExtNum} when ExtNum > 0 ->
+		     [{var,"Extensions"}];
+		 _ ->
+		     []
+	     end,
     %handle extensions
     {extgrouppos,ExtGroupPosLen}  = extgroup_pos_and_length(CL),
     NewExtList = wrap_extensionAdditionGroups(ExtList,ExtGroupPosLen),
-    gen_enc_components_call1(Erule,TopType,NewExtList,Rpos,MaybeComma,DynamicEnc,Ext);
-gen_enc_components_call(Erule,TopType, CompList, MaybeComma, DynamicEnc, Ext) ->
+    {Imm1,_} = gen_enc_components_call1(Erule,TopType,NewExtList,Rpos,DynamicEnc,Ext,[]),
+    Imm0 ++ [ExtImm|Imm1];
+gen_enc_components_call(Erule,TopType, CompList, DynamicEnc, Ext) ->
     %% The type has no extensionmarker
-    gen_enc_components_call1(Erule,TopType,CompList,1,MaybeComma,DynamicEnc,Ext).
+    {Imm,_} = gen_enc_components_call1(Erule,TopType,CompList,1,DynamicEnc,Ext,[]),
+    Imm.
 
 gen_enc_components_call1(Erule,TopType,
 			 [C=#'ComponentType'{name=Cname,typespec=Type,prop=Prop}|Rest],
 			 Tpos,
-			 MaybeComma, DynamicEnc, Ext) ->
+			 DynamicEnc, Ext, Acc) ->
 
-    put(component_type,{true,C}), 
-    %% information necessary in asn1ct_gen_per_rt2ct:gen_encode_prim
     TermNo =
 	case C#'ComponentType'.textual_order of
 	    undefined ->
@@ -892,90 +843,91 @@ gen_enc_components_call1(Erule,TopType,
 	    CanonicalNum ->
 		CanonicalNum
 	end,
-    emit(MaybeComma),
-    case Prop of
-	'OPTIONAL' ->
-	    gen_enc_component_optional(Erule,TopType,Cname,Type,TermNo,DynamicEnc,Ext);
-	{'DEFAULT',DefVal} ->
-	    gen_enc_component_default(Erule,TopType,Cname,Type,TermNo,DynamicEnc,Ext,DefVal);
-	_ ->
-	    case Ext of
-		{ext,ExtPos,_} when Tpos >= ExtPos ->
-		    gen_enc_component_optional(Erule,TopType,Cname,Type,TermNo,DynamicEnc,Ext);
-		_ ->
-		    gen_enc_component_mandatory(Erule,TopType,Cname,Type,TermNo,DynamicEnc,Ext)
-	    end
-    end,
-
-    erase(component_type),
-
-    case Rest of
-	[] ->
-	    Tpos+1;
-	_ ->
-	    emit({com,nl}),
-	    gen_enc_components_call1(Erule,TopType,Rest,Tpos+1,"",DynamicEnc,Ext)
+    Val = make_var(val),
+    {Imm0,Element} = asn1ct_imm:enc_element(TermNo+1, Val),
+    Imm1 = gen_enc_line_imm(Erule, TopType, Cname, Type, Element, DynamicEnc, Ext),
+    Category = case {Prop,Ext} of
+		   {'OPTIONAL',_} ->
+		       optional;
+		   {{'DEFAULT',DefVal},_} ->
+		       {default,DefVal};
+		   {_,{ext,ExtPos,_}} when Tpos >= ExtPos ->
+		       optional;
+		   {_,_} ->
+		       mandatory
+	       end,
+    Imm2 = case Category of
+	       mandatory ->
+		   Imm1;
+	       optional ->
+		   asn1ct_imm:enc_absent(Element, [asn1_NOVALUE], Imm1);
+	       {default,Def} ->
+		   DefValues = def_values(Type, Def),
+		   asn1ct_imm:enc_absent(Element, DefValues, Imm1)
+	   end,
+    Imm = case Imm2 of
+	      [] -> [];
+	      _ -> Imm0 ++ Imm2
+	  end,
+    gen_enc_components_call1(Erule, TopType, Rest, Tpos+1, DynamicEnc, Ext, [Imm|Acc]);
+gen_enc_components_call1(_Erule,_TopType,[],Pos,_,_, Acc) ->
+    ImmList = lists:reverse(Acc),
+    {ImmList,Pos}.
+
+def_values(#type{def=#'Externaltypereference'{module=Mod,type=Type}}, Def) ->
+    #typedef{typespec=T} = asn1_db:dbget(Mod, Type),
+    def_values(T, Def);
+def_values(#type{def={'BIT STRING',[]}}, Bs) when is_bitstring(Bs) ->
+    case asn1ct:use_legacy_types() of
+	false ->
+	    [asn1_DEFAULT,Bs];
+	true ->
+	    ListBs = [B || <<B:1>> <= Bs],
+	    IntBs = lists:foldl(fun(B, A) ->
+					(A bsl 1) bor B
+				end, 0, lists:reverse(ListBs)),
+	    Sz = bit_size(Bs),
+	    Compact = case 8 - Sz rem 8 of
+			  8 ->
+			      {0,Bs};
+			  Unused ->
+			      {Unused,<<Bs:Sz/bits,0:Unused>>}
+		      end,
+	    [asn1_DEFAULT,Bs,Compact,ListBs,IntBs]
     end;
-gen_enc_components_call1(_Erule,_TopType,[],Pos,_,_,_) ->
-	Pos.
-
-gen_enc_component_default(Erule,TopType,Cname,Type,Pos,DynamicEnc,Ext,DefaultVal) ->
-    Element = make_element(Pos+1,asn1ct_gen:mk_var(asn1ct_name:curr(val))),
-    emit({"case ",Element," of",nl}),
-%    emit({"asn1_DEFAULT -> [];",nl}),
-    emit({"DFLT when DFLT == asn1_DEFAULT; DFLT == ",{asis,DefaultVal}," -> [];",nl}),
-
-    asn1ct_name:new(tmpval),
-    emit({{curr,tmpval}," ->",nl}),
-    InnerType = asn1ct_gen:get_inner(Type#type.def),
-    emit({nl,"%% attribute number ",Pos," with type ",
-	      InnerType,nl}),
-    NextElement = asn1ct_gen:mk_var(asn1ct_name:curr(tmpval)),
-    gen_enc_line(Erule,TopType,Cname,Type,NextElement, Pos,DynamicEnc,Ext),
-    emit({nl,"end"}).
-
-gen_enc_component_optional(Erule,TopType,Cname,
-			   Type=#type{def=#'SEQUENCE'{
-					extaddgroup=Number,
-					components=_ExtGroupCompList}},
-			   Pos,DynamicEnc,Ext) when is_integer(Number) ->
-
-    Element = make_element(Pos+1,asn1ct_gen:mk_var(asn1ct_name:curr(val))),
-    emit({"case ",Element," of",nl}),
-
-    emit({"asn1_NOVALUE -> [];",nl}),
-    asn1ct_name:new(tmpval),
-    emit({{curr,tmpval}," ->",nl}),
-    InnerType = asn1ct_gen:get_inner(Type#type.def),
-    emit({nl,"%% attribute number ",Pos," with type ",
-	      InnerType,nl}),
-    NextElement = asn1ct_gen:mk_var(asn1ct_name:curr(tmpval)),
-    gen_enc_line(Erule,TopType,Cname,Type,NextElement, Pos,DynamicEnc,Ext),
-    emit({nl,"end"});
-gen_enc_component_optional(Erule,TopType,Cname,Type,Pos,DynamicEnc,Ext) ->
-    Element = make_element(Pos+1,asn1ct_gen:mk_var(asn1ct_name:curr(val))),
-    emit({"case ",Element," of",nl}),
-
-    emit({"asn1_NOVALUE -> [];",nl}),
-    asn1ct_name:new(tmpval),
-    emit({{curr,tmpval}," ->",nl}),
-    InnerType = asn1ct_gen:get_inner(Type#type.def),
-    emit({nl,"%% attribute number ",Pos," with type ",
-	      InnerType,nl}),
-    NextElement = asn1ct_gen:mk_var(asn1ct_name:curr(tmpval)),
-    gen_enc_line(Erule,TopType,Cname,Type,NextElement, Pos,DynamicEnc,Ext),
-    emit({nl,"end"}).
+def_values(#type{def={'BIT STRING',[_|_]=Ns}}, List) when is_list(List) ->
+    Bs = asn1ct_gen:named_bitstring_value(List, Ns),
+    As = case asn1ct:use_legacy_types() of
+	     false ->
+		 [List,Bs];
+	     true ->
+		 ListBs = [B || <<B:1>> <= Bs],
+		 IntBs = lists:foldl(fun(B, A) ->
+					     (A bsl 1) bor B
+				     end, 0, lists:reverse(ListBs)),
+		 [List,Bs,ListBs,IntBs]
+	 end,
+    {call,per_common,is_default_bitstring,As};
+def_values(#type{def={'INTEGER',Ns}}, Def) ->
+    [asn1_DEFAULT,Def|case lists:keyfind(Def, 2, Ns) of
+			  false -> [];
+			  {Val,Def} -> [Val]
+		      end];
+def_values(_, Def) ->
+    [asn1_DEFAULT,Def].
+
+gen_enc_line_imm(Erule, TopType, Cname, Type, Element, DynamicEnc, Ext) ->
+    Imm0 = gen_enc_line_imm_1(Erule, TopType, Cname, Type,
+			      Element, DynamicEnc),
+    Aligned = is_aligned(Erule),
+    case Ext of
+	{ext,_Ep2,_} ->
+	    asn1ct_imm:per_enc_open_type(Imm0, Aligned);
+	_ ->
+	    Imm0
+    end.
 
-gen_enc_component_mandatory(Erule,TopType,Cname,Type,Pos,DynamicEnc,Ext) ->
-    InnerType = asn1ct_gen:get_inner(Type#type.def),
-    emit({nl,"%% attribute number ",Pos," with type ",
-	      InnerType,nl}),
-    gen_enc_line(Erule,TopType,Cname,Type,[],Pos,DynamicEnc,Ext).
-
-gen_enc_line(Erule,TopType, Cname, Type, [], Pos,DynamicEnc,Ext) ->
-    Element = make_element(Pos+1,asn1ct_gen:mk_var(asn1ct_name:curr(val))),
-    gen_enc_line(Erule,TopType,Cname,Type,Element, Pos,DynamicEnc,Ext);
-gen_enc_line(Erule,TopType,Cname,Type,Element, _Pos,DynamicEnc,Ext) ->
+gen_enc_line_imm_1(Erule, TopType, Cname, Type, Element, DynamicEnc) ->
     Atype = 
 	case Type of
 	    #type{def=#'ObjectClassFieldType'{type=InnerType}} ->
@@ -983,81 +935,182 @@ gen_enc_line(Erule,TopType,Cname,Type,Element, _Pos,DynamicEnc,Ext) ->
 	    _  ->
 		asn1ct_gen:get_inner(Type#type.def)
 	end,
-
-    case Ext of
-	{ext,_Ep1,_} ->
-	    asn1ct_func:need({Erule,encode_open_type,1}),
-	    asn1ct_func:need({Erule,complete,1}),
-	    emit(["encode_open_type(complete("]);
-	_ -> true
-    end,
-
+    Aligned = is_aligned(Erule),
     case Atype of
 	{typefield,_} ->
-	    case DynamicEnc of
-		{_LeadingAttrName,Fun} ->
-		    case (Type#type.def)#'ObjectClassFieldType'.fieldname of
-			{Name,RestFieldNames} when is_atom(Name) ->
-			    asn1ct_func:need({Erule,complete,1}),
-			    asn1ct_func:need({Erule,encode_open_type,1}),
-			    emit({"encode_open_type(complete(",nl}),
-			    emit({"   ",Fun,"(",{asis,Name},", ",
-				  Element,", ",{asis,RestFieldNames},")))"});
-			Other ->
-			    throw({asn1,{'internal error',Other}})
-		    end
-	    end;
-	{objectfield,PrimFieldName1,PFNList} ->
-	    case DynamicEnc of
-		{_LeadingAttrName,Fun} ->
-		    asn1ct_func:need({Erule,complete,1}),
-		    asn1ct_func:need({Erule,encode_open_type,1}),
-		    emit({"encode_open_type("
-			  "complete(",nl}),
-		    emit({"   ",Fun,"(",{asis,PrimFieldName1},
-			  ", ",Element,", ",{asis,PFNList},")))"})
+	    {_LeadingAttrName,Fun} = DynamicEnc,
+	    case (Type#type.def)#'ObjectClassFieldType'.fieldname of
+		{Name,RestFieldNames} when is_atom(Name) ->
+		    Imm = enc_var_type_call(Erule, Name, RestFieldNames,
+					    Type, Fun, Element),
+		    asn1ct_imm:per_enc_open_type(Imm, Aligned)
 	    end;
 	_ ->
 	    CurrMod = get(currmod),
 	    case asn1ct_gen:type(Atype) of
-		#'Externaltypereference'{module=Mod,type=EType} when 
-		      (CurrMod==Mod) ->
-		    emit({"'enc_",EType,"'(",Element,")"});
+		#'Externaltypereference'{module=CurrMod,type=EType} ->
+		    [{apply,{local,enc_func(EType),Atype},[Element]}];
 		#'Externaltypereference'{module=Mod,type=EType} ->
-		    emit({"'",Mod,"':'enc_",
-			  EType,"'(",Element,")"});
+		    [{apply,{Mod,enc_func(EType),Atype},[Element]}];
 		{primitive,bif} ->
-		    asn1ct_gen_per:gen_encode_prim(Erule, Type, Element);
+		    asn1ct_gen_per:gen_encode_prim_imm(Element, Type, Aligned);
 		'ASN1_OPEN_TYPE' ->
 		    case Type#type.def of
 			#'ObjectClassFieldType'{type=OpenType} ->
-			    asn1ct_gen_per:gen_encode_prim(Erule,
-							   #type{def=OpenType},
-							   Element);
+			    asn1ct_gen_per:gen_encode_prim_imm(Element,
+							       #type{def=OpenType},
+							       Aligned);
 			_ ->
-			    asn1ct_gen_per:gen_encode_prim(Erule, Type,
-							   Element)
+			    asn1ct_gen_per:gen_encode_prim_imm(Element,
+							       Type,
+							       Aligned)
 		    end;
 		{constructed,bif} ->
 		    NewTypename = [Cname|TopType],
+		    Enc = enc_func(asn1ct_gen:list2name(NewTypename)),
 		    case {Type#type.tablecinf,DynamicEnc} of
 			{[{objfun,_}|_R],{_,EncFun}} ->
-			    emit({"'enc_",
-				  asn1ct_gen:list2name(NewTypename),
-				  "'(",Element,", ",EncFun,")"});
+			    [{apply,{local,Enc,Type},[Element,EncFun]}];
 			_ ->
-			    emit({"'enc_",
-				  asn1ct_gen:list2name(NewTypename),
-				  "'(",Element,")"})
+			    [{apply,{local,Enc,Type},[Element]}]
 		    end
 	    end
-    end,
-    case Ext of 
-	{ext,_Ep2,_} ->
-	    emit("))");
-	_ -> true
     end.
 
+enc_func(Type) ->
+    enc_func("enc_", Type).
+
+enc_func(Prefix, Name) ->
+    list_to_atom(lists:concat([Prefix,Name])).
+
+enc_var_type_call(Erule, Name, RestFieldNames,
+		  #type{tablecinf=TCI}, Fun, Val) ->
+    [{objfun,#'Externaltypereference'{module=Xmod,type=Xtype}}] = TCI,
+    #typedef{typespec=ObjSet0} = asn1_db:dbget(Xmod, Xtype),
+    #'ObjectSet'{class=Class,set=ObjSet1} = ObjSet0,
+    #'Externaltypereference'{module=ClMod,type=ClType} = Class,
+    #classdef{typespec=ClassDef} = asn1_db:dbget(ClMod, ClType),
+    #objectclass{fields=ClassFields} = ClassDef,
+    Extensible = lists:member('EXTENSIONMARK', ObjSet1),
+    ObjSet = index_object_set(Erule, ClType, Name,
+			      ObjSet1, ClassFields),
+    Key = erlang:md5(term_to_binary({encode,ObjSet,RestFieldNames,Extensible})),
+    TypeName = [ClType,Name],
+    Imm = enc_objset_imm(Erule, TypeName, Name, ObjSet,
+			 RestFieldNames, Extensible),
+    Lambda = {lambda,[{var,"Val"},{var,"Id"}],Imm},
+    Gen = fun(_Fd, N) ->
+		  Aligned = is_aligned(Erule),
+		  emit([{asis,N},"(Val, Id) ->",nl]),
+		  asn1ct_imm:enc_cg(Imm, Aligned),
+		  emit([".",nl])
+	  end,
+    Prefix = lists:concat(["enc_os_",Name]),
+    [{call_gen,Prefix,Key,Gen,Lambda,[Val,Fun]}].
+
+index_object_set(_Erules, _ClType, Name, Set0, ClassFields) ->
+    Set = index_object_set_1(Name, Set0, ClassFields),
+    lists:sort(Set).
+
+index_object_set_1(Name, [{_,Key,Code}|T], ClassFields) ->
+    case index_object_set_2(Name, Code, ClassFields) of
+	none ->
+	    index_object_set_1(Name, T, ClassFields);
+	Type ->
+	    [{Key,Type}|index_object_set_1(Name, T, ClassFields)]
+    end;
+index_object_set_1(Name, [_|T], ClassFields) ->
+    index_object_set_1(Name, T, ClassFields);
+index_object_set_1(_, [], _) ->
+    [].
+
+index_object_set_2(Name, [{Name,Type}|_], _ClassFields) ->
+    Type;
+index_object_set_2(Name, [_|T], ClassFields) ->
+    index_object_set_2(Name, T, ClassFields);
+index_object_set_2(Name, [], ClassFields) ->
+    case lists:keyfind(Name, 2, ClassFields) of
+	{typefield,Name,'OPTIONAL'} ->
+	    none;
+	{objectfield,Name,_,_,'OPTIONAL'} ->
+	    none;
+	{typefield,Name,{'DEFAULT',#type{}=Type}} ->
+	    InnerType = asn1ct_gen:get_inner(Type#type.def),
+	    case asn1ct_gen:type(InnerType) of
+		{primitive,bif} ->
+		    #typedef{name={primitive,bif},typespec=Type};
+		{constructed,bif} ->
+		    #typedef{name={constructed,bif},typespec=Type}
+	    end
+    end.
+
+enc_objset_imm(Erule, TypeName, Component, ObjSet,
+	       RestFieldNames, Extensible) ->
+    Aligned = is_aligned(Erule),
+    E = {error,
+	 fun() ->
+		 emit(["exit({'Type not compatible with table constraint',"
+		       "{component,",{asis,Component},"},"
+		       "{value,Val},"
+		       "{unique_name_and_value,'_'}})",nl])
+	 end},
+    [{'cond',
+      [[{eq,{var,"Id"},Key}|
+	enc_obj(Erule, Obj, TypeName, RestFieldNames, Aligned)] ||
+	  {Key,Obj} <- ObjSet] ++
+	  [['_',case Extensible of
+		    false ->
+			E;
+		    true ->
+			case asn1ct:use_legacy_types() of
+			    false ->
+				{call,per_common,open_type_to_binary,
+				 [{var,"Val"}]};
+			    true ->
+				{call,per_common,legacy_open_type_to_binary,
+				 [{var,"Val"}]}
+			end
+		end]]}].
+
+enc_obj(Erule, Obj, TypeName, RestFieldNames0, Aligned) ->
+    Val = {var,"Val"},
+    case Obj of
+	#typedef{name={constructed,bif},typespec=Type}=Def ->
+	    Prefix = "enc_outlined_",
+	    Key = {enc_outlined,Def},
+	    Gen = fun(_Fd, Name) ->
+			  gen_enc_obj(Erule, Name, TypeName, Type)
+		  end,
+	    [{call_gen,Prefix,Key,Gen,undefined,[Val]}];
+	#typedef{name={primitive,bif},typespec=Def} ->
+	    asn1ct_gen_per:gen_encode_prim_imm({var,"Val"}, Def, Aligned);
+	#typedef{name=Type} ->
+	    [{apply,{local,enc_func(Type),Type},[{var,"Val"}]}];
+	#'Externalvaluereference'{module=Mod,value=Value} ->
+	    case asn1_db:dbget(Mod, Value) of
+		#typedef{typespec=#'Object'{def=Def}} ->
+		    {object,_,Fields} = Def,
+		    [NextField|RestFieldNames] = RestFieldNames0,
+		    {NextField,Typedef} = lists:keyfind(NextField, 1, Fields),
+		    enc_obj(Erule, Typedef, TypeName,
+			    RestFieldNames, Aligned)
+	    end;
+	#'Externaltypereference'{module=Mod,type=Type} ->
+	    Func = enc_func(Type),
+	    case get(currmod) of
+		Mod ->
+		    [{apply,{local,Func,Obj},[{var,"Val"}]}];
+		_ ->
+		    [{apply,{Mod,Func,Obj},[{var,"Val"}]}]
+	    end
+    end.
+
+gen_enc_obj(Erules, Name, Typename, Type) ->
+    emit([{asis,Name},"(Val) ->",nl]),
+    InnerType = asn1ct_gen:get_inner(Type#type.def),
+    asn1ct_gen:gen_encode_constructed(Erules, Typename,
+				      InnerType, Type).
+
 gen_dec_components_call(Erule, TopType, {Root,ExtList},
 			DecInfObj, Ext, NumberOfOptionals) ->
     gen_dec_components_call(Erule,TopType,{Root,ExtList,[]},
@@ -1163,14 +1216,6 @@ gen_dec_comp_call(Comp, Erule, TopType, Tpos, OptTable, DecInfObj,
 			emit(["{",{curr,tmpterm},", ",{next,bytes},"} = "]),
 			St
 		end;
-	%%{objectfield,_,_} when Ext == noext, Prop == mandatory ->
-	    {{objectfield,_,_},true} ->
-		fun(St) ->
-			asn1ct_name:new(term),
-			asn1ct_name:new(tmpterm),
-			emit(["{",{curr,tmpterm},", ",{next,bytes},"} = "]),
-			St
-		end;
 	_ ->
 	    case Type of
 		#type{def=#'SEQUENCE'{
@@ -1204,7 +1249,8 @@ gen_dec_comp_call(Comp, Erule, TopType, Tpos, OptTable, DecInfObj,
 
 comp_call_pre_post(noext, mandatory, _, _, _, _, _, _) ->
     {[],[]};
-comp_call_pre_post(noext, Prop, _, _, TextPos, OptTable, NumOptionals, Ext) ->
+comp_call_pre_post(noext, Prop, _, Type, TextPos,
+		   OptTable, NumOptionals, Ext) ->
     %% OPTIONAL or DEFAULT
     OptPos = get_optionality_pos(TextPos, OptTable),
     Element = case NumOptionals - OptPos of
@@ -1222,7 +1268,7 @@ comp_call_pre_post(noext, Prop, _, _, TextPos, OptTable, NumOptionals, Ext) ->
 	      emit([";",nl,
 		    "0 ->",nl,
 		    "{"]),
-	      gen_dec_component_no_val(Ext, Prop),
+	      gen_dec_component_no_val(Ext, Type, Prop),
 	      emit([",",{curr,bytes},"}",nl,
 		    "end"]),
 	      St
@@ -1244,10 +1290,10 @@ comp_call_pre_post({ext,_,_}, Prop, Pos, Type, _, _, _, Ext) ->
 			       components=ExtGroupCompList2}}
 		    when is_integer(Number2)->
 		      emit("{extAddGroup,"),
-		      gen_dec_extaddGroup_no_val(Ext, ExtGroupCompList2),
+		      gen_dec_extaddGroup_no_val(Ext, Type, ExtGroupCompList2),
 		      emit("}");
 		  _ ->
-		      gen_dec_component_no_val(Ext, Prop)
+		      gen_dec_component_no_val(Ext, Type, Prop)
 	      end,
 	      emit([",",{curr,bytes},"}",nl,
 		    "end"]),
@@ -1262,21 +1308,22 @@ is_mandatory_predef_tab_c(_, _, {"got objfun through args","ObjFun"}) ->
 is_mandatory_predef_tab_c(_,_,_) ->
     true.
 
-gen_dec_extaddGroup_no_val(Ext,[#'ComponentType'{prop=Prop}])->
-    gen_dec_component_no_val(Ext,Prop),
+gen_dec_extaddGroup_no_val(Ext, Type, [#'ComponentType'{prop=Prop}])->
+    gen_dec_component_no_val(Ext, Type, Prop),
     ok;
-gen_dec_extaddGroup_no_val(Ext,[#'ComponentType'{prop=Prop}|Rest])->
-    gen_dec_component_no_val(Ext,Prop),
-    emit({","}),
-    gen_dec_extaddGroup_no_val(Ext,Rest);
-gen_dec_extaddGroup_no_val(_, []) ->
+gen_dec_extaddGroup_no_val(Ext, Type, [#'ComponentType'{prop=Prop}|Rest])->
+    gen_dec_component_no_val(Ext, Type, Prop),
+    emit(","),
+    gen_dec_extaddGroup_no_val(Ext, Type, Rest);
+gen_dec_extaddGroup_no_val(_, _, []) ->
     ok.
 
-gen_dec_component_no_val(_,{'DEFAULT',DefVal}) ->
+gen_dec_component_no_val(_, Type, {'DEFAULT',DefVal0}) ->
+    DefVal = asn1ct_gen:conform_value(Type, DefVal0),
     emit([{asis,DefVal}]);
-gen_dec_component_no_val(_,'OPTIONAL') ->
+gen_dec_component_no_val(_, _, 'OPTIONAL') ->
     emit({"asn1_NOVALUE"});
-gen_dec_component_no_val({ext,_,_},mandatory) ->
+gen_dec_component_no_val({ext,_,_}, _, mandatory) ->
     emit({"asn1_NOVALUE"}).
     
 
@@ -1350,25 +1397,19 @@ gen_dec_line_special(Erule, {typefield,_}, _TopType, Comp,
 		false -> % This is in a choice with typefield components
 		    {Name,RestFieldNames} =
 			(Type#type.def)#'ObjectClassFieldType'.fieldname,
-
-		    asn1ct_name:new(reason),
 		    Imm = asn1ct_imm:per_dec_open_type(is_aligned(Erule)),
 		    BytesVar = asn1ct_gen:mk_var(asn1ct_name:curr(bytes)),
 		    {TmpTerm,TempBuf} = asn1ct_imm:dec_slim_cg(Imm, BytesVar),
+		    emit([com,nl]),
+		    #type{tablecinf=[{objfun,
+				      #'Externaltypereference'{module=Xmod,
+							       type=Xtype}}]} =
+			Type,
+		    gen_dec_open_type(Erule, "ObjFun", {Xmod,Xtype},
+				      '_', {'_',{Name,RestFieldNames},
+					    'Result',TmpTerm,mandatory}),
 		    emit([com,nl,
-			  {next,bytes}," = ",TempBuf,com,nl,
-			  indent(2),"case (catch ObjFun(",
-			  {asis,Name},",",TmpTerm,",telltype,",
-			  {asis,RestFieldNames},")) of", nl]),
-		    emit([indent(4),"{'EXIT',",{curr,reason},"} ->",nl]),
-		    emit([indent(6),"exit({'Type not ",
-			  "compatible with table constraint', ",
-			  {curr,reason},"});",nl]),
-		    asn1ct_name:new(tmpterm),
-		    emit([indent(4),"{",{curr,tmpterm},", _} ->",nl]),
-		    emit([indent(6),"{",{asis,Cname},", {",{curr,tmpterm},", ",
-			  {next,bytes},"}}",nl]),
-		    emit([indent(2),"end"]),
+			  "{",{asis,Cname},",{Result,",TempBuf,"}}"]),
 		    {[],PrevSt};
 		{"got objfun through args","ObjFun"} ->
 		    %% this is when the generated code gots the
@@ -1388,27 +1429,22 @@ gen_dec_line_special(Erule, {typefield,_}, _TopType, Comp,
 		    BytesVar = asn1ct_gen:mk_var(asn1ct_name:curr(bytes)),
 		    asn1ct_imm:dec_code_gen(Imm, BytesVar),
 		    emit([com,nl]),
+		    #type{tablecinf=[{objfun,
+				      #'Externaltypereference'{module=Xmod,
+							       type=Xtype}}]} =
+			Type,
+		    Term = asn1ct_gen:mk_var(asn1ct_name:curr(term)),
+		    TmpTerm = asn1ct_gen:mk_var(asn1ct_name:curr(tmpterm)),
 		    if
 			Prop =:= mandatory ->
-			    emit([{curr,term}," =",nl,"      "]);
-			true ->
-			    emit(["     {"])
-		    end,
-		    emit(["case (catch ObjFun(",{asis,Name},",",
-			  {curr,tmpterm},",telltype,",
-			  {asis,RestFieldNames},")) of", nl]),
-		    emit(["    {'EXIT',",{curr,reason},"} ->",nl]),
-		    emit([indent(6),"exit({'Type not ",
-			  "compatible with table constraint', ",
-			  {curr,reason},"});",nl]),
-		    asn1ct_name:new(tmpterm),
-		    emit([indent(4),"{",{curr,tmpterm},", _} ->",nl]),
-		    emit([indent(6),{curr,tmpterm},nl]),
-		    emit([indent(2),"end"]),
-		    if
-			Prop =:= mandatory ->
-			    ok;
+			    gen_dec_open_type(Erule, "ObjFun", {Xmod,Xtype},
+					      '_', {'_',{Name,RestFieldNames},
+						    Term,TmpTerm,Prop});
 			true ->
+			    emit(["     {"]),
+			    gen_dec_open_type(Erule, "ObjFun", {Xmod,Xtype},
+					      '_', {'_',{Name,RestFieldNames},
+						    '_',TmpTerm,Prop}),
 			    emit([",",nl,{curr,tmpbytes},"}"])
 		    end,
 		    {[],PrevSt};
@@ -1425,19 +1461,6 @@ gen_dec_line_special(Erule, {typefield,_}, _TopType, Comp,
 		       Prop}],PrevSt}
 	    end
     end;
-gen_dec_line_special(Erule, {objectfield,PrimFieldName1,PFNList}, _TopType,
-		     Comp, _DecInfObj) ->
-    fun({_BytesVar,PrevSt}) ->
-	    Imm = asn1ct_imm:per_dec_open_type(is_aligned(Erule)),
-	    BytesVar = asn1ct_gen:mk_var(asn1ct_name:curr(bytes)),
-	    asn1ct_imm:dec_code_gen(Imm, BytesVar),
-	    #'ComponentType'{name=Cname,prop=Prop} = Comp,
-	    SaveBytes = [{Cname,{PrimFieldName1,PFNList},
-			  asn1ct_gen:mk_var(asn1ct_name:curr(term)),
-			  asn1ct_gen:mk_var(asn1ct_name:curr(tmpterm)),
-			  Prop}],
-	    {SaveBytes,PrevSt}
-    end;
 gen_dec_line_special(Erule, Atype, TopType, Comp, DecInfObj) ->
     case gen_dec_line_other(Erule, Atype, TopType, Comp) of
 	Fun when is_function(Fun, 1) ->
@@ -1458,14 +1481,11 @@ gen_dec_line_special(Erule, Atype, TopType, Comp, DecInfObj) ->
 gen_dec_line_dec_inf(Comp, DecInfObj) ->
     #'ComponentType'{name=Cname} = Comp,
     case DecInfObj of
-	{Cname,{_,OSet,UniqueFName,ValIndex}} ->
+	{Cname,{_,_OSet,_UniqueFName,ValIndex}} ->
 	    Term = asn1ct_gen:mk_var(asn1ct_name:curr(term)),
 	    ValueMatch = value_match(ValIndex,Term),
-	    {ObjSetMod,ObjSetName} = OSet,
 	    emit([",",nl,
-		  "ObjFun = ",{asis,ObjSetMod},
-		  ":'getdec_",ObjSetName,"'(",
-		  {asis,UniqueFName},", ",ValueMatch,")"]);
+		  "ObjFun = ",ValueMatch]);
 	_ ->
 	    ok
     end.
@@ -1492,86 +1512,67 @@ gen_dec_line_other(Erule, Atype, TopType, Comp) ->
 		[{objfun,_}|_R] ->
 		    fun(BytesVar) ->
 			    emit({"'dec_",asn1ct_gen:list2name(NewTypename),
-				  "'(",BytesVar,", telltype, ObjFun)"})
+				  "'(",BytesVar,", ObjFun)"})
 		    end;
 		_ ->
 		    fun(BytesVar) ->
 			    emit({"'dec_",asn1ct_gen:list2name(NewTypename),
-				  "'(",BytesVar,", telltype)"})
+				  "'(",BytesVar,")"})
 		    end
 	    end
     end.
 
-gen_enc_choice(Erule,TopType,CompList,Ext) ->
-    gen_enc_choice_tag(Erule, CompList, [], Ext),
-    emit({com,nl}),
-    emit({"case element(1,Val) of",nl}),
-    gen_enc_choice2(Erule,TopType, CompList, Ext),
-    emit({nl,"end"}).
-
-gen_enc_choice_tag(Erule, {C1,C2}, _, _) ->
-    N1 = get_name_list(C1),
-    N2 = get_name_list(C2),
-    call(Erule,set_choice,
-	 ["element(1, Val)",
-	  {asis,{N1,N2}},
-	  {asis,{length(N1),length(N2)}}]);
-gen_enc_choice_tag(Erule, {C1,C2,C3}, _, _) ->
-    N1 = get_name_list(C1),
-    N2 = get_name_list(C2),
-    N3 = get_name_list(C3),
-    Root = N1 ++ N3,
-    call(Erule,set_choice,
-	 ["element(1, Val)",
-	  {asis,{Root,N2}},
-	  {asis,{length(Root),length(N2)}}]);
-gen_enc_choice_tag(Erule, C, _, _) ->
-    N = get_name_list(C),
-    call(Erule,set_choice,
-	 ["element(1, Val)",
-	  {asis,N},{asis,length(N)}]).
-
-get_name_list(L) ->
-    get_name_list(L,[]).
-
-get_name_list([#'ComponentType'{name=Name}|T], Acc) ->
-    get_name_list(T,[Name|Acc]);
-get_name_list([], Acc) ->
-    lists:reverse(Acc).
-
-
-gen_enc_choice2(Erule,TopType, {L1,L2}, Ext) ->
-    gen_enc_choice2(Erule, TopType, L1 ++ L2, 0, [], Ext);
-gen_enc_choice2(Erule, TopType, {L1,L2,L3}, Ext) ->
-    gen_enc_choice2(Erule, TopType, L1 ++ L3 ++ L2, 0, [], Ext);
-gen_enc_choice2(Erule,TopType, L, Ext) ->
-    gen_enc_choice2(Erule,TopType, L, 0, [], Ext).
+gen_enc_choice(Erule, TopType, {Root,Exts}, Ext) ->
+    Constr = choice_constraint(Root),
+    gen_enc_choices(Root, Erule, TopType, 0, Constr, Ext) ++
+	gen_enc_choices(Exts, Erule, TopType, 0, ext, Ext);
+gen_enc_choice(Erule, TopType, {Root,Exts,[]}, Ext) ->
+    gen_enc_choice(Erule, TopType, {Root,Exts}, Ext);
+gen_enc_choice(Erule, TopType, Root, Ext) when is_list(Root) ->
+    Constr = choice_constraint(Root),
+    gen_enc_choices(Root, Erule, TopType, 0, Constr, Ext).
+
+choice_constraint(L) ->
+    case length(L) of
+	0 -> [{'SingleValue',0}];
+	Len -> [{'ValueRange',{0,Len-1}}]
+    end.
 
-gen_enc_choice2(Erule, TopType, [H|T], Pos, Sep0, Ext) ->
+gen_enc_choices([H|T], Erule, TopType, Pos, Constr, Ext) ->
     #'ComponentType'{name=Cname,typespec=Type} = H,
+    Aligned = is_aligned(Erule),
     EncObj =
 	case asn1ct_gen:get_constraint(Type#type.constraint,
 				       componentrelation) of
 	    no -> 
 		case Type#type.tablecinf of
 		    [{objfun,_}|_] ->
-			{"got objfun through args","ObjFun"};
+			{"got objfun through args",{var,"ObjFun"}};
 		    _ ->
 			false
 		end;
 	    _ ->
-		{no_attr,"ObjFun"}
+		{no_attr,{var,"ObjFun"}}
 	end,
-    emit([Sep0,{asis,Cname}," ->",nl]),
-    DoExt = case Ext of
-		{ext,ExtPos,_} when Pos + 1 < ExtPos -> noext;
-		_ -> Ext
+    DoExt = case Constr of
+		ext -> Ext;
+		_ -> noext
 	    end,
-    gen_enc_line(Erule, TopType, Cname, Type, "element(2, Val)",
-		 Pos+1, EncObj, DoExt),
-    Sep = [";",nl],
-    gen_enc_choice2(Erule, TopType, T, Pos+1, Sep, Ext);
-gen_enc_choice2(_, _, [], _, _, _)  -> ok.
+    Tag = case {Ext,Constr} of
+	      {noext,_} ->
+		  asn1ct_imm:per_enc_integer(Pos, Constr, Aligned);
+	      {{ext,_,_},ext} ->
+		  [{put_bits,1,1,[1]}|
+		   asn1ct_imm:per_enc_small_number(Pos, Aligned)];
+	      {{ext,_,_},_} ->
+		  [{put_bits,0,1,[1]}|
+		   asn1ct_imm:per_enc_integer(Pos, Constr, Aligned)]
+	  end,
+    Body = gen_enc_line_imm(Erule, TopType, Cname, Type, {var,"ChoiceVal"},
+			    EncObj, DoExt),
+    Imm = Tag ++ Body,
+    [{Cname,Imm}|gen_enc_choices(T, Erule, TopType, Pos+1, Constr, Ext)];
+gen_enc_choices([], _, _, _, _, _)  -> [].
 
 %% Generate the code for CHOICE. If the CHOICE is extensible,
 %% the structure of the generated code is as follows:
@@ -1704,9 +1705,6 @@ gen_dec_choice2(Erule, TopType, [H0|T], Pos, Sep0, Pre) ->
     gen_dec_choice2(Erule, TopType, T, Pos+1, Sep, Pre);
 gen_dec_choice2(_, _, [], _, _, _)  -> ok.
 
-indent(N) ->
-    lists:duplicate(N,32). % 32 = space
-
 make_elements(I,Val,ExtCnames) ->
     make_elements(I,Val,ExtCnames,[]).
 
@@ -1720,7 +1718,7 @@ make_elements(_I,_,[],Acc) ->
     lists:reverse(Acc).
 
 make_element(I, Val) ->
-    io_lib:format("element(~w,~s)", [I,Val]).
+    lists:flatten(io_lib:format("element(~w, ~s)", [I,Val])).
 
 emit_extaddgroupTerms(VarSeries,[_]) ->
     asn1ct_name:new(VarSeries),
@@ -1788,5 +1786,12 @@ value_match1(Value,[],Acc,Depth) ->
 value_match1(Value,[{VI,_}|VIs],Acc,Depth) ->
     value_match1(Value,VIs,Acc++lists:concat(["element(",VI,","]),Depth+1).
 
-is_optimized(per) -> true;
-is_optimized(uper) -> false.
+enc_dig_out_value([], Value) ->
+    {[],Value};
+enc_dig_out_value([{N,_}|T], Value) ->
+    {Imm0,Dst0} = enc_dig_out_value(T, Value),
+    {Imm,Dst} = asn1ct_imm:enc_element(N, Dst0),
+    {Imm0++Imm,Dst}.
+
+make_var(Base) ->
+    {var,atom_to_list(asn1ct_gen:mk_var(asn1ct_name:curr(Base)))}.
diff --git a/lib/asn1/src/asn1ct_eval_per.funcs b/lib/asn1/src/asn1ct_eval_per.funcs
deleted file mode 100644
index a1ea5cd043..0000000000
--- a/lib/asn1/src/asn1ct_eval_per.funcs
+++ /dev/null
@@ -1,2 +0,0 @@
-{per,encode_constrained_number,2}.
-{per,encode_small_number,1}.
diff --git a/lib/asn1/src/asn1ct_eval_uper.funcs b/lib/asn1/src/asn1ct_eval_uper.funcs
deleted file mode 100644
index 884a486f40..0000000000
--- a/lib/asn1/src/asn1ct_eval_uper.funcs
+++ /dev/null
@@ -1,2 +0,0 @@
-{uper,encode_constrained_number,2}.
-{uper,encode_small_number,1}.
diff --git a/lib/asn1/src/asn1ct_func.erl b/lib/asn1/src/asn1ct_func.erl
index ab0dbcce8f..0cd72acf9d 100644
--- a/lib/asn1/src/asn1ct_func.erl
+++ b/lib/asn1/src/asn1ct_func.erl
@@ -1,25 +1,27 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
 %%
 
 -module(asn1ct_func).
--export([start_link/0,need/1,call/3,generate/1]).
+-export([start_link/0,need/1,call/3,call_gen/3,call_gen/4,
+	 generate/1,is_used/1]).
 -export([init/1,handle_call/3,handle_cast/2,terminate/2]).
 
 start_link() ->
@@ -28,15 +30,33 @@ start_link() ->
     ok.
 
 call(M, F, Args) ->
-    MFA = {M,F,length(Args)},
+    A = length(Args),
+    MFA = {M,F,A},
     need(MFA),
-    asn1ct_gen:emit([F,"(",call_args(Args, ""),")"]).
+    case M of
+	binary ->
+	    asn1ct_gen:emit(["binary:",F,"(",call_args(Args, ""),")"]);
+	_ ->
+	    asn1ct_gen:emit([F,"(",call_args(Args, ""),")"])
+    end.
 
+need({binary,_,_}) ->
+    ok;
+need({erlang,_,_}) ->
+    ok;
 need(MFA) ->
     asn1ct_rtt:assert_defined(MFA),
     cast({need,MFA}).
 
+call_gen(Prefix, Key, Gen, Args) when is_function(Gen, 2) ->
+    F = req({gen_func,Prefix,Key,Gen}),
+    asn1ct_gen:emit([{asis,F},"(",call_args(Args, ""),")"]).
+
+call_gen(Prefix, Key, Gen) when is_function(Gen, 2) ->
+    req({gen_func,Prefix,Key,Gen}).
+
 generate(Fd) ->
+    do_generate(Fd),
     Used0 = req(get_used),
     erase(?MODULE),
     Used = sofs:set(Used0, [mfa]),
@@ -45,6 +65,10 @@ generate(Fd) ->
     Funcs = sofs:to_external(Funcs0),
     ok = file:write(Fd, Funcs).
 
+is_used({_,_,_}=MFA) ->
+    req({is_used,MFA}).
+
+
 req(Req) ->
     gen_server:call(get(?MODULE), Req, infinity).
 
@@ -53,10 +77,13 @@ cast(Req) ->
 
 %%% Internal functions.
 
--record(st, {used}).
+-record(st, {used,				%Used functions
+	     gen,				%Dynamically generated functions
+	     gc=1				%Counter for generated functions
+	    }).
 
 init([]) ->
-    St = #st{used=gb_sets:empty()},
+    St = #st{used=gb_sets:empty(),gen=gb_trees:empty()},
     {ok,St}.
 
 handle_cast({need,MFA}, #st{used=Used0}=St) ->
@@ -69,7 +96,23 @@ handle_cast({need,MFA}, #st{used=Used0}=St) ->
     end.
 
 handle_call(get_used, _From, #st{used=Used}=St) ->
-    {stop,normal,gb_sets:to_list(Used),St}.
+    {stop,normal,gb_sets:to_list(Used),St};
+handle_call(get_gen, _From, #st{gen=G0}=St) ->
+    {L,G} = do_get_gen(gb_trees:to_list(G0), [], []),
+    {reply,L,St#st{gen=gb_trees:from_orddict(G)}};
+handle_call({gen_func,Prefix,Key,GenFun}, _From, #st{gen=G0,gc=Gc0}=St) ->
+    case gb_trees:lookup(Key, G0) of
+	none ->
+	    Name = list_to_atom(Prefix ++ integer_to_list(Gc0)),
+	    Gc = Gc0 + 1,
+	    G = gb_trees:insert(Key, {Name,GenFun}, G0),
+	    {reply,Name,St#st{gen=G,gc=Gc}};
+	{value,{Name,_}} ->
+	    {reply,Name,St}
+    end;
+handle_call({is_used,MFA}, _From, #st{used=Used}=St) ->
+    {reply,gb_sets:is_member(MFA, Used),St}.
+
 
 terminate(_, _) ->
     ok.
@@ -98,3 +141,22 @@ update_worklist([H|T], Used, Ws) ->
 	    update_worklist(T, Used, Ws)
     end;
 update_worklist([], _, Ws) -> Ws.
+
+do_get_gen([{_,{_,done}}=Keep|T], Gacc, Kacc) ->
+    do_get_gen(T, Gacc, [Keep|Kacc]);
+do_get_gen([{K,{Name,_}=V}|T], Gacc, Kacc) ->
+    do_get_gen(T, [V|Gacc], [{K,{Name,done}}|Kacc]);
+do_get_gen([], Gacc, Kacc) ->
+    {lists:sort(Gacc),lists:reverse(Kacc)}.
+
+do_generate(Fd) ->
+    case req(get_gen) of
+	[] ->
+	    ok;
+	[_|_]=Gen ->
+	    _ = [begin
+		     ok = file:write(Fd, "\n"),
+		     GenFun(Fd, Name)
+		 end || {Name,GenFun} <- Gen],
+	    do_generate(Fd)
+    end.
diff --git a/lib/asn1/src/asn1ct_gen.erl b/lib/asn1/src/asn1ct_gen.erl
index 9095e145a3..bfaffa13bf 100644
--- a/lib/asn1/src/asn1ct_gen.erl
+++ b/lib/asn1/src/asn1ct_gen.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -23,23 +24,27 @@
 
 -export([demit/1,
 	 emit/1,
+	 open_output_file/1,close_output_file/0,
 	 get_inner/1,type/1,def_to_tag/1,prim_bif/1,
 	 list2name/1,
 	 list2rname/1,
 	 constructed_suffix/2,
 	 unify_if_string/1,
-	 gen_check_call/7,
 	 get_constraint/2,
 	 insert_once/2,
 	 ct_gen_module/1,
 	 index2suffix/1,
-	 get_record_name_prefix/0]).
+	 get_record_name_prefix/0,
+	 conform_value/2,
+	 named_bitstring_value/2]).
 -export([pgen/5,
 	 mk_var/1, 
 	 un_hyphen_var/1]).
 -export([gen_encode_constructed/4,
 	 gen_decode_constructed/4]).
 
+-define(SUPPRESSION_FUNC, 'dialyzer-suppressions').
+
 %% pgen(Outfile, Erules, Module, TypeOrVal, Options)
 %% Generate Erlang module (.erl) and (.hrl) file corresponding to an ASN.1 module
 %% .hrl file is only generated if necessary
@@ -68,8 +73,7 @@ pgen_module(OutFile,Erules,Module,
     HrlGenerated = pgen_hrl(Erules,Module,TypeOrVal,Options,Indent),
     asn1ct_name:start(),
     ErlFile = lists:concat([OutFile,".erl"]),
-    Fid = fopen(ErlFile),
-    put(gen_file_out,Fid),
+    _ = open_output_file(ErlFile),
     asn1ct_func:start_link(),
     gen_head(Erules,Module,HrlGenerated),
     pgen_exports(Erules,Module,TypeOrVal),
@@ -83,10 +87,18 @@ pgen_module(OutFile,Erules,Module,
 	  "%%%",nl,
 	  "%%% Run-time functions.",nl,
 	  "%%%",nl]),
-    asn1ct_func:generate(Fid),
-    file:close(Fid),
+    dialyzer_suppressions(Erules),
+    Fd = get(gen_file_out),
+    asn1ct_func:generate(Fd),
+    close_output_file(),
+    _ = erase(outfile),
     asn1ct:verbose("--~p--~n",[{generated,ErlFile}],Options).
 
+dialyzer_suppressions(Erules) ->
+    emit([nl,
+	  {asis,?SUPPRESSION_FUNC},"(Arg) ->",nl]),
+    Rtmod = ct_gen_module(Erules),
+    Rtmod:dialyzer_suppressions(Erules).
 
 pgen_typeorval(Erules,Module,N2nConvEnums,{Types,Values,_Ptypes,_Classes,Objects,ObjectSets}) ->
     Rtmod = ct_gen_module(Erules),
@@ -94,11 +106,6 @@ pgen_typeorval(Erules,Module,N2nConvEnums,{Types,Values,_Ptypes,_Classes,Objects
     pgen_values(Erules,Module,Values),
     pgen_objects(Rtmod,Erules,Module,Objects),
     pgen_objectsets(Rtmod,Erules,Module,ObjectSets),
-    case catch lists:member(der,get(encoding_options)) of
-	true ->
-	    pgen_check_defaultval(Erules,Module);
-	_ -> ok
-    end,
     pgen_partial_decode(Rtmod,Erules,Module).
 
 pgen_values(_,_,[]) ->
@@ -174,23 +181,6 @@ pgen_objectsets(Rtmod,Erules,Module,[H|T]) ->
     Rtmod:gen_objectset_code(Erules,TypeDef),
     pgen_objectsets(Rtmod,Erules,Module,T).
 
-pgen_check_defaultval(Erules,Module) ->
-    CheckObjects = asn1ct_table:to_list(check_functions),
-    case get(asndebug) of
-	true ->
-	    FileName = lists:concat([Module,".table"]),
-	    {ok,IoDevice} = file:open(FileName,[write]),
-	    Fun =
-		fun(X)->
-			io:format(IoDevice,"~n~n************~n~n~p~n~n*****"
-				  "********~n~n",[X]) 
-		end,
-	    lists:foreach(Fun,CheckObjects),
-	    file:close(IoDevice);
-	_ -> ok
-    end,
-    gen_check_defaultval(Erules,Module,CheckObjects).
-
 pgen_partial_decode(Rtmod,Erule,Module) when Erule == ber ->
     pgen_partial_inc_dec(Rtmod,Erule,Module),
     pgen_partial_dec(Rtmod,Erule,Module);
@@ -538,165 +528,35 @@ gen_part_decode_funcs({constructed,bif},TypeName,
     emit(["  'dec_",TypeName,"'(Data,",{asis,Tag},")"]);
 gen_part_decode_funcs({primitive,bif},_TypeName,
 		      {_Name,undecoded,Tag,Type}) ->
-    % Argument no 6 is 0, i.e. bit 6 for primitive encoding.
-    asn1ct_gen_ber_bin_v2:gen_dec_prim(ber_bin_v2,Type,"Data",Tag,[],0,", mandatory, ");
+    asn1ct_gen_ber_bin_v2:gen_dec_prim(Type, "Data", Tag);
 gen_part_decode_funcs(WhatKind,_TypeName,{_,Directive,_,_}) ->
     throw({error,{asn1,{"Not implemented yet",WhatKind," partial incomplete directive:",Directive}}}).
 
-
-gen_types(Erules,Tname,{RootL1,ExtList,RootL2}) 
+%% EncDec = 'gen_encode' | 'gen_decode'
+gen_types(Erules, Tname, {RootL1,ExtList,RootL2}, EncDec)
   when is_list(RootL1), is_list(RootL2) ->
-    gen_types(Erules,Tname,RootL1),
-    Rtmod = ct_gen_module(Erules),
-    gen_types(Erules,Tname,Rtmod:extaddgroup2sequence(ExtList)),
-    gen_types(Erules,Tname,RootL2);
-gen_types(Erules,Tname,{RootList,ExtList}) when is_list(RootList) ->
-    gen_types(Erules,Tname,RootList),
+    gen_types(Erules, Tname, RootL1, EncDec),
     Rtmod = ct_gen_module(Erules),
-    gen_types(Erules,Tname,Rtmod:extaddgroup2sequence(ExtList));
-gen_types(Erules,Tname,[{'EXTENSIONMARK',_,_}|Rest]) ->
-    gen_types(Erules,Tname,Rest);
-gen_types(Erules,Tname,[ComponentType|Rest]) ->
+    gen_types(Erules, Tname, Rtmod:extaddgroup2sequence(ExtList), EncDec),
+    gen_types(Erules, Tname, RootL2, EncDec);
+gen_types(Erules, Tname, {RootList,ExtList}, EncDec) when is_list(RootList) ->
+    gen_types(Erules, Tname, RootList, EncDec),
     Rtmod = ct_gen_module(Erules),
+    gen_types(Erules, Tname, Rtmod:extaddgroup2sequence(ExtList), EncDec);
+gen_types(Erules, Tname, [{'EXTENSIONMARK',_,_}|T], EncDec) ->
+    gen_types(Erules, Tname, T, EncDec);
+gen_types(Erules, Tname, [ComponentType|T], EncDec) ->
     asn1ct_name:clear(),
-    Rtmod:gen_encode(Erules,Tname,ComponentType),
-    asn1ct_name:clear(),
-    Rtmod:gen_decode(Erules,Tname,ComponentType),
-    gen_types(Erules,Tname,Rest);
-gen_types(_,_,[]) ->
-    true;
-gen_types(Erules,Tname,Type) when is_record(Type,type) ->
     Rtmod = ct_gen_module(Erules),
-    asn1ct_name:clear(),
-    Rtmod:gen_encode(Erules,Tname,Type),
-    asn1ct_name:clear(),
-    Rtmod:gen_decode(Erules,Tname,Type).
-
-gen_check_defaultval(Erules,Module,[{Name,Type}|Rest]) ->
-    gen_check_func(Name,Type),
-    gen_check_defaultval(Erules,Module,Rest);
-gen_check_defaultval(_,_,[]) ->
-    ok.
-
-gen_check_func(Name,FType = #type{def=Def}) ->
-    EncName = ensure_atom(Name),
-    emit({{asis,EncName},"(_V,asn1_DEFAULT) ->",nl,"   true;",nl}),
-    emit({{asis,EncName},"(V,V) ->",nl,"   true;",nl}),
-    emit({{asis,EncName},"(V,{_,V}) ->",nl,"   true;",nl}),
-    case Def of
-	{'SEQUENCE OF',Type} ->
-	    gen_check_sof(Name,'SEQOF',Type);
-	{'SET OF',Type} ->
-	    gen_check_sof(Name,'SETOF',Type);
-	#'SEQUENCE'{components=Components} ->
-	    gen_check_sequence(Name,Components);
-	#'SET'{components=Components} ->
-	    gen_check_sequence(Name,Components);
-	{'CHOICE',Components} ->
-	    gen_check_choice(Name,Components);
-	#'Externaltypereference'{type=T} ->
-	    emit({{asis,EncName},"(DefaultValue,Value) ->",nl}),
-	    emit({"   '",list2name([T,check]),"'(DefaultValue,Value).",nl});
-	MaybePrim ->
-	    InnerType = get_inner(MaybePrim),
-	    case type(InnerType) of
-		{primitive,bif} ->
-		    emit({{asis,EncName},"(DefaultValue,Value) ->",nl,"   "}),
-		    gen_prim_check_call(get_inner(InnerType),"DefaultValue","Value",
-					FType),
-		    emit({".",nl,nl});
-		_ ->
-		    throw({asn1_error,{unknown,type,MaybePrim}})
-	    end
-    end.
-
-gen_check_sof(Name,SOF,Type) ->
-    EncName = ensure_atom(Name),
-    NewName = ensure_atom(list2name([sorted,Name])),
-    emit({{asis,EncName},"(V1,V2) ->",nl}),
-    emit({"   ",{asis,NewName},"(lists:sort(V1),lists:sort(V2)).",nl,nl}),
-    emit({{asis,NewName},"([],[]) ->",nl,"   true;",nl}),
-    emit({{asis,NewName},"([DV|DVs],[V|Vs]) ->",nl,"   "}),
-    InnerType = get_inner(Type#type.def),
-    case type(InnerType) of
-	{primitive,bif} ->
-	    gen_prim_check_call(get_inner(InnerType),"DV","V",Type),
-	    emit({",",nl});
-	{constructed,bif} ->
-	    emit([{asis,ensure_atom(list2name([SOF,Name]))},"(DV, V),",nl]);
-	#'Externaltypereference'{type=T} ->
-	    emit([{asis,ensure_atom(list2name([T,check]))},"(DV,V),",nl]);
-	'ASN1_OPEN_TYPE' ->
-	    emit(["DV = V,",nl]);
-	_ ->
-	    emit(["DV = V,",nl])
-    end,
-    emit({"   ",{asis,NewName},"(DVs,Vs).",nl,nl}).
-
-gen_check_sequence(Name, []) ->
-    emit([{asis,ensure_atom(Name)},"(_,_) ->",nl,
-	 "    throw(badval).",nl,nl]);
-gen_check_sequence(Name,Components) ->
-    emit([{asis,ensure_atom(Name)},"(DefaultValue,Value) ->",nl]),
-    gen_check_sequence(Name,Components,1).
-
-gen_check_sequence(Name,[#'ComponentType'{name=N,typespec=Type}|Cs],Num) ->
-    InnerType = get_inner(Type#type.def),
-    NthDefV = ["element(",Num+1,",DefaultValue)"],
-    NthV = ["element(",Num+1,",Value)"],
-    gen_check_func_call(Name,Type,InnerType,NthDefV,NthV,N),
-    case Cs of
-	[] ->
-	    emit({".",nl,nl});
-	_ ->
-	    emit({",",nl}),
-	    gen_check_sequence(Name,Cs,Num+1)
-    end.
-
-gen_check_choice(Name,CList=[#'ComponentType'{}|_Cs]) ->
-    emit([{asis,ensure_atom(Name)},"({Id,DefaultValue},{Id,Value}) ->",nl]),
-    emit(["   case Id of",nl]),
-    gen_check_choice_components(Name,CList,1).
-
-gen_check_choice_components(_,[],_)->
+    Rtmod:EncDec(Erules, Tname, ComponentType),
+    gen_types(Erules, Tname, T, EncDec);
+gen_types(_, _, [], _) ->
     ok;
-gen_check_choice_components(Name,[#'ComponentType'{name=N,typespec=Type}|
-				  Cs],Num) ->
-    Ind6 = "      ",
-    InnerType = get_inner(Type#type.def),
-    emit({Ind6,"'",N,"' ->",nl,Ind6}),
-    gen_check_func_call(Name,Type,InnerType,{var,"defaultValue"},
-			{var,"value"},N),
-    case Cs of
-	[] ->
-	    emit({nl,"   end.",nl,nl});
-	_ ->
-	    emit({";",nl}),
-	    gen_check_choice_components(Name,Cs,Num+1)
-    end.
+gen_types(Erules, Tname, #type{}=Type, EncDec) ->
+    asn1ct_name:clear(),
+    Rtmod = ct_gen_module(Erules),
+    Rtmod:EncDec(Erules, Tname, Type).
 
-gen_check_func_call(Name,Type,InnerType,DefVal,Val,N) ->
-    case type(InnerType) of
-	{primitive,bif} ->
-	    emit("   "),
-	    gen_prim_check_call(get_inner(InnerType),DefVal,Val,Type);
-	#'Externaltypereference'{type=T} ->
-	    emit({"   ",{asis,ensure_atom(list2name([T,check]))},"(",DefVal,",",Val,")"});
-	'ASN1_OPEN_TYPE' ->
-	    emit(["   if",nl,
-		  "      ",DefVal," == ",Val," -> true;",nl,
-		  "      true -> throw({error,{asn1_open_type}})",nl,
-		  "   end",nl]);
-	{constructed,bif} ->
-	    emit(["   ",{asis,ensure_atom(list2name([N,Name]))},"(",DefVal,",",Val,")"]);
-	_ ->
-	    emit(["   if",nl,
-		  "      ",DefVal," == ",Val," -> true;",nl,
-		  "      true -> throw({error,{asn1_open_type}})",nl,
-		  "   end",nl])
-    end.
-		  
-    
 %% VARIOUS GENERATOR STUFF 
 %% *************************************************
 %%**************************************************
@@ -736,25 +596,25 @@ gen_encode_constructed(Erules,Typename,InnerType,D) when is_record(D,type) ->
 	'SET' ->
 	    Rtmod:gen_encode_set(Erules,Typename,D),
 	    #'SET'{components=Components} = D#type.def,
-	    gen_types(Erules,Typename,Components);
+	    gen_types(Erules, Typename, Components, gen_encode);
 	'SEQUENCE' ->
 	    Rtmod:gen_encode_sequence(Erules,Typename,D),
 	    #'SEQUENCE'{components=Components} = D#type.def,
-	    gen_types(Erules,Typename,Components);
+	    gen_types(Erules, Typename, Components, gen_encode);
 	'CHOICE' ->
 	    Rtmod:gen_encode_choice(Erules,Typename,D),
 	    {_,Components} = D#type.def,
-	    gen_types(Erules,Typename,Components);
+	    gen_types(Erules, Typename, Components, gen_encode);
 	'SEQUENCE OF' ->
 	    Rtmod:gen_encode_sof(Erules,Typename,InnerType,D),
 	    {_,Type} = D#type.def,
 	    NameSuffix = asn1ct_gen:constructed_suffix(InnerType,Type#type.def),
-	    gen_types(Erules,[NameSuffix|Typename],Type);
+	    gen_types(Erules, [NameSuffix|Typename], Type, gen_encode);
 	'SET OF' ->
 	    Rtmod:gen_encode_sof(Erules,Typename,InnerType,D),
 	    {_,Type} = D#type.def,
 	    NameSuffix = asn1ct_gen:constructed_suffix(InnerType,Type#type.def),
-	    gen_types(Erules,[NameSuffix|Typename],Type);
+	    gen_types(Erules, [NameSuffix|Typename], Type, gen_encode);
 	_ ->
 	    exit({nyi,InnerType})
     end;
@@ -767,26 +627,37 @@ gen_decode_constructed(Erules,Typename,InnerType,D) when is_record(D,type) ->
     asn1ct:step_in_constructed(), %% updates namelist for exclusive decode
     case InnerType of
 	'SET' ->
-	    Rtmod:gen_decode_set(Erules,Typename,D);
+	    Rtmod:gen_decode_set(Erules,Typename,D),
+	    #'SET'{components=Components} = D#type.def,
+	    gen_types(Erules, Typename, Components, gen_decode);
 	'SEQUENCE' ->
-	    Rtmod:gen_decode_sequence(Erules,Typename,D);
+	    Rtmod:gen_decode_sequence(Erules,Typename,D),
+	    #'SEQUENCE'{components=Components} = D#type.def,
+	    gen_types(Erules, Typename, Components, gen_decode);
 	'CHOICE' ->
-	    Rtmod:gen_decode_choice(Erules,Typename,D);
+	    Rtmod:gen_decode_choice(Erules,Typename,D),
+	    {_,Components} = D#type.def,
+	    gen_types(Erules, Typename, Components, gen_decode);
 	'SEQUENCE OF' ->
-	    Rtmod:gen_decode_sof(Erules,Typename,InnerType,D);
+	    Rtmod:gen_decode_sof(Erules,Typename,InnerType,D),
+	    {_,#type{def=Def}=Type} = D#type.def,
+	    NameSuffix = asn1ct_gen:constructed_suffix(InnerType, Def),
+	    gen_types(Erules, [NameSuffix|Typename], Type, gen_decode);
 	'SET OF' ->
-	    Rtmod:gen_decode_sof(Erules,Typename,InnerType,D);
-	_ ->
-	    exit({nyi,InnerType})
+	    Rtmod:gen_decode_sof(Erules,Typename,InnerType,D),
+	    {_,#type{def=Def}=Type} = D#type.def,
+	    NameSuffix = asn1ct_gen:constructed_suffix(InnerType, Def),
+	    gen_types(Erules, [NameSuffix|Typename], Type, gen_decode)
     end;
 
-
 gen_decode_constructed(Erules,Typename,InnerType,D) when is_record(D,typedef) ->
     gen_decode_constructed(Erules,Typename,InnerType,D#typedef.typespec).
 
 
 pgen_exports(Erules,_Module,{Types,Values,_,_,Objects,ObjectSets}) ->
-    emit(["-export([encoding_rule/0,bit_string_format/0]).",nl]),
+    emit(["-export([encoding_rule/0,bit_string_format/0,",nl,
+	  "         legacy_erlang_types/0]).",nl]),
+    emit(["-export([",{asis,?SUPPRESSION_FUNC},"/1]).",nl]),
     case Types of
 	[] -> ok;
 	_ ->
@@ -798,7 +669,12 @@ pgen_exports(Erules,_Module,{Types,Values,_,_,Objects,ObjectSets}) ->
 		    gen_exports1(Types,"enc_",1)
 	    end,
 	    emit({"-export([",nl}),
-	    gen_exports1(Types,"dec_",2)
+	    case Erules of
+		ber ->
+		    gen_exports1(Types, "dec_", 2);
+		_ ->
+		    gen_exports1(Types, "dec_", 1)
+	    end
     end,
     case [X || {n2n,X} <- get(encoding_options)] of
 	[] -> ok;
@@ -819,10 +695,7 @@ pgen_exports(Erules,_Module,{Types,Values,_,_,Objects,ObjectSets}) ->
 	_ ->
 	    case erule(Erules) of
 		per ->
-		    emit({"-export([",nl}),
-		    gen_exports1(Objects,"enc_",3),
-		    emit({"-export([",nl}),
-		    gen_exports1(Objects,"dec_",4);
+		    ok;
 		ber ->
 		    emit({"-export([",nl}),
 		    gen_exports1(Objects,"enc_",3),
@@ -833,10 +706,15 @@ pgen_exports(Erules,_Module,{Types,Values,_,_,Objects,ObjectSets}) ->
     case ObjectSets of
 	[] -> ok;
 	_ ->
-	    emit({"-export([",nl}),
-	    gen_exports1(ObjectSets,"getenc_",2),
-	    emit({"-export([",nl}),
-	    gen_exports1(ObjectSets,"getdec_",2)
+	    case erule(Erules) of
+		per ->
+		    ok;
+		ber ->
+		    emit({"-export([",nl}),
+		    gen_exports1(ObjectSets, "getenc_",1),
+		    emit({"-export([",nl}),
+		    gen_exports1(ObjectSets, "getdec_",1)
+	    end
     end,
     emit({"-export([info/0]).",nl}),
     gen_partial_inc_decode_exports(),
@@ -900,41 +778,45 @@ pgen_dispatcher(Erules,_Module,{[],_Values,_,_,_Objects,_ObjectSets}) ->
 pgen_dispatcher(Erules,_Module,{Types,_Values,_,_,_Objects,_ObjectSets}) ->
     emit(["-export([encode/2,decode/2]).",nl,nl]),
     gen_info_functions(Erules),
-    NoFinalPadding = lists:member(no_final_padding,get(encoding_options)),
-    {Call,BytesAsBinary} =
-	case Erules of
-	    per ->
-		asn1ct_func:need({Erules,complete,1}),
-		{["complete(encode_disp(Type, Data))"],"Bytes"};
-	    ber ->
-		{"encode_disp(Type,Data)","iolist_to_binary(Bytes)"};
-	    uper when NoFinalPadding == true ->
-		asn1ct_func:need({Erules,complete_NFP,1}),
-		{"complete_NFP(encode_disp(Type, Data))","Bytes"};
-	    uper ->
-		asn1ct_func:need({Erules,complete,1}),
-		{["complete(encode_disp(Type, Data))"],"Bytes"}
-	end,
-    emit(["encode(Type,Data) ->",nl,
-	  "case catch ",Call," of",nl,
-	  "  {'EXIT',{error,Reason}} ->",nl,
-	  "    {error,Reason};",nl,
-	  "  {'EXIT',Reason} ->",nl,
-	  "    {error,{asn1,Reason}};",nl,
-	  "  {Bytes,_Len} ->",nl,
-	  "    {ok,",BytesAsBinary,"};",nl,
-	  "  Bytes ->",nl,
-	  "    {ok,",BytesAsBinary,"}",nl,
-	  "end.",nl,nl]),
-
-    Return_rest = lists:member(undec_rest,get(encoding_options)),
+
+    Options = get(encoding_options),
+    NoFinalPadding = lists:member(no_final_padding, Options),
+    NoOkWrapper = proplists:get_bool(no_ok_wrapper, Options),
+
+    Call = case Erules of
+	       per ->
+		   asn1ct_func:need({Erules,complete,1}),
+		   "complete(encode_disp(Type, Data))";
+	       ber ->
+		   "iolist_to_binary(element(1, encode_disp(Type, Data)))";
+	       uper when NoFinalPadding == true ->
+		   asn1ct_func:need({Erules,complete_NFP,1}),
+		   "complete_NFP(encode_disp(Type, Data))";
+	       uper ->
+		   asn1ct_func:need({Erules,complete,1}),
+		   "complete(encode_disp(Type, Data))"
+	   end,
+
+    emit(["encode(Type, Data) ->",nl]),
+    case NoOkWrapper of
+	true ->
+	    emit(["  ",Call,"."]);
+	false ->
+	    emit(["try ",Call," of",nl,
+		  "  Bytes ->",nl,
+		  "    {ok,Bytes}",nl,
+		  try_catch()])
+    end,
+    emit([nl,nl]),
+
+    Return_rest = proplists:get_bool(undec_rest, Options),
     Data = case {Erules,Return_rest} of
 	       {ber,true} -> "Data0";
 	       _ -> "Data"
 	   end,
 
     emit(["decode(Type,",Data,") ->",nl]),
-    DecAnonymous =
+    DecWrap =
 	case {Erules,Return_rest} of
 	    {ber,false} ->
 		asn1ct_func:need({ber,ber_decode_nif,1}),
@@ -946,49 +828,26 @@ pgen_dispatcher(Erules,_Module,{Types,_Values,_,_,_Objects,_ObjectSets}) ->
 	    _ ->
 		"Data"
 	end,
-    DecWrap = case Erules of
-		  ber ->
-		      DecAnonymous;
-		  _ -> "Data"
-	      end,
-	    
-    emit(["case catch decode_disp(Type,",DecWrap,") of",nl,
-	  "  {'EXIT',{error,Reason}} ->",nl,
-	  "    {error,Reason};",nl,
-	  "  {'EXIT',Reason} ->",nl,
-	  "    {error,{asn1,Reason}};",nl]),
-    case {Erules,Return_rest} of 
-	{ber,false} ->
-	    emit(["  Result ->",nl,
-		  "    {ok,Result}",nl]);
-	{ber,true} ->
-	    emit(["  Result ->",nl,
-		  "    {ok,Result,Rest}",nl]);
-	{_,false} ->
-	    emit(["  {X,_Rest} ->",nl,
-		  "    {ok,X};",nl,
-		  "  {X,_Rest,_Len} ->",nl,
-		  "    {ok,X}",nl]);
-	{per,true} ->
-	    emit(["  {X,{_,Rest}} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,{_,Rest},_Len} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,Rest} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,Rest,_Len} ->",nl,
-		  "    {ok,X,Rest}",nl]);
-	{uper,true} ->
-	    emit(["  {X,{_,Rest}} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,{_,Rest},_Len} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,Rest} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,Rest,_Len} ->",nl,
-		  "    {ok,X,Rest}",nl])
+    emit([case NoOkWrapper of
+	      false -> "try";
+	      true -> "case"
+	  end, " decode_disp(Type, ",DecWrap,") of",nl]),
+    case erule(Erules) of
+	ber ->
+	    emit(["  Result ->",nl]);
+	per ->
+	    emit(["  {Result,Rest} ->",nl])
+    end,
+    case Return_rest of
+	false -> result_line(NoOkWrapper, ["Result"]);
+	true ->  result_line(NoOkWrapper, ["Result","Rest"])
+    end,
+    case NoOkWrapper of
+	false ->
+	    emit([nl,try_catch(),nl,nl]);
+	true ->
+	    emit([nl,"end.",nl,nl])
     end,
-    emit(["end.",nl,nl]),
 
     gen_decode_partial_incomplete(Erules),
 
@@ -999,16 +858,40 @@ pgen_dispatcher(Erules,_Module,{Types,_Values,_,_,_Objects,_ObjectSets}) ->
 	    gen_partial_inc_dispatcher();
 	_PerOrPer_bin -> 
 	    gen_dispatcher(Types,"encode_disp","enc_",""),
-	    gen_dispatcher(Types,"decode_disp","dec_",",mandatory")
+	    gen_dispatcher(Types,"decode_disp","dec_","")
     end,
-    emit([nl]),
-    emit({nl,nl}).
+    emit([nl,nl]).
+
+result_line(NoOkWrapper, Items) ->
+    S = ["    "|case NoOkWrapper of
+		    false -> result_line_1(["ok"|Items]);
+		    true -> result_line_1(Items)
+		end],
+    emit(lists:flatten(S)).
+
+result_line_1([SingleItem]) ->
+    SingleItem;
+result_line_1(Items) ->
+    ["{",string:join(Items, ","),"}"].
+
+try_catch() ->
+    ["  catch",nl,
+     "    Class:Exception when Class =:= error; Class =:= exit ->",nl,
+     "      case Exception of",nl,
+     "        {error,Reason}=Error ->",nl,
+     "          Error;",nl,
+     "        Reason ->",nl,
+     "         {error,{asn1,Reason}}",nl,
+     "      end",nl,
+     "end."].
 
 gen_info_functions(Erules) ->
     emit(["encoding_rule() -> ",
 	  {asis,Erules},".",nl,nl,
 	  "bit_string_format() -> ",
-	  {asis,asn1ct:get_bit_string_format()},".",nl,nl]).
+	  {asis,asn1ct:get_bit_string_format()},".",nl,nl,
+	  "legacy_erlang_types() -> ",
+	  {asis,asn1ct:use_legacy_types()},".",nl,nl]).
 
 gen_decode_partial_incomplete(ber) ->
     case {asn1ct:read_config_data(partial_incomplete_decode),
@@ -1060,9 +943,10 @@ gen_partial_inc_dispatcher() ->
 	    ok;
 	{Data1,Data2} ->
 %	    io:format("partial_incomplete_decode: ~p~ninc_type_pattern: ~p~n",[Data,Data2]),
-	    gen_partial_inc_dispatcher(Data1,Data2)
+	    gen_partial_inc_dispatcher(Data1, Data2, "")
     end.
-gen_partial_inc_dispatcher([{FuncName,TopType,_Pattern}|Rest],TypePattern) ->
+
+gen_partial_inc_dispatcher([{FuncName,TopType,_Pattern}|Rest], TypePattern, Sep) ->
     TPattern =
 	case lists:keysearch(FuncName,1,TypePattern) of
 	    {value,{_,TP}} -> TP;
@@ -1076,13 +960,13 @@ gen_partial_inc_dispatcher([{FuncName,TopType,_Pattern}|Rest],TypePattern) ->
 	    _ ->
 		atom_to_list(TopType)
 	end,
-    emit(["decode_partial_inc_disp('",TopTypeName,"',Data) ->",nl,
+    emit([Sep,
+	  "decode_partial_inc_disp('",TopTypeName,"',Data) ->",nl,
 	  "  ",{asis,list_to_atom(lists:concat(["dec-inc-",FuncName2]))},
-	  "(Data);",nl]),
-    gen_partial_inc_dispatcher(Rest,TypePattern);
-gen_partial_inc_dispatcher([],_) ->
-    emit(["decode_partial_inc_disp(Type,_Data) ->",nl,
-	  "  exit({error,{asn1,{undefined_type,Type}}}).",nl]).
+	  "(Data)"]),
+    gen_partial_inc_dispatcher(Rest, TypePattern, ";\n");
+gen_partial_inc_dispatcher([], _, _) ->
+    emit([".",nl]).
 
 gen_dispatcher([F1,F2|T],FuncName,Prefix,ExtraArg) ->
 	emit([FuncName,"('",F1,"',Data) -> '",Prefix,F1,"'(Data",ExtraArg,")",";",nl]),
@@ -1107,9 +991,23 @@ pgen_info() ->
 
 open_hrl(OutFile,Module) ->
     File = lists:concat([OutFile,".hrl"]),
-    Fid = fopen(File),
-    put(gen_file_out,Fid),
-    gen_hrlhead(Module).
+    _ = open_output_file(File),
+    gen_hrlhead(Module),
+    Protector = hrl_protector(OutFile),
+    emit(["-ifndef(",Protector,").\n",
+	  "-define(",Protector,", true).\n"
+	  "\n"]).
+
+hrl_protector(OutFile) ->
+    BaseName = filename:basename(OutFile),
+    P = "_" ++ string:to_upper(BaseName) ++ "_HRL_",
+    [if
+	 $A =< C, C =< $Z -> C;
+	 $a =< C, C =< $a -> C;
+	 $0 =< C, C =< $9 -> C;
+	 true -> $_
+     end || C <- P].
+
 
 %% EMIT functions ************************
 %% ***************************************
@@ -1181,15 +1079,19 @@ call_args([A|As], Sep) ->
     [Sep,do_emit(A)|call_args(As, ", ")];
 call_args([], _) -> [].
 
-fopen(F) ->
+open_output_file(F) ->
     case file:open(F, [write,raw,delayed_write]) of
-	{ok, Fd} -> 
+	{ok,Fd} ->
+	    put(gen_file_out, Fd),
 	    Fd;
 	{error, Reason} ->
 	    io:format("** Can't open file ~p ~n", [F]),
 	    exit({error,Reason})
     end.
 
+close_output_file() ->
+    ok = file:close(erase(gen_file_out)).
+
 pgen_hrl(Erules,Module,TypeOrVal,Options,_Indent) ->
     put(currmod,Module),
     {Types,Values,Ptypes,_,_,_} = TypeOrVal,
@@ -1212,8 +1114,9 @@ pgen_hrl(Erules,Module,TypeOrVal,Options,_Indent) ->
 	0 ->
 	    0;
 	Y ->
-	    Fid = get(gen_file_out),
-	    file:close(Fid),
+	    Protector = hrl_protector(get(outfile)),
+	    emit(["-endif. %% ",Protector,"\n"]),
+	    close_output_file(),
 	    asn1ct:verbose("--~p--~n",
 			   [{generated,lists:concat([get(outfile),".hrl"])}],
 			   Options),
@@ -1331,15 +1234,23 @@ gen_record(TorPtype,Name,Type,Num) when is_record(Type,type) ->
 			emit({"}).",nl,nl}),
 			Tr ++ ExtensionList2;
 		    {Rootl1,Extl,Rootl2} ->
+			case Rootl1 =/= [] andalso Extl++Rootl2 =/= [] of
+			    true -> emit([com]);
+			    false -> ok
+			end,
 			case Rootl1 of
-			    [] -> true;
-			    _ -> emit([",",nl])
+			    [_|_] -> emit([nl]);
+			    [] -> ok
 			end,
 			emit(["%% with extensions",nl]),
 			gen_record2(Name,'SEQUENCE',Extl,"",ext),
+			case Extl =/= [] andalso Rootl2 =/= [] of
+			    true -> emit([com]);
+			    false -> ok
+			end,
 			case Extl of
-			    [_H|_] when Rootl2 /= [] -> emit([",",nl]);
-			    _ -> ok
+			    [_|_] -> emit([nl]);
+			    [] -> ok
 			end,
 			emit(["%% end of extensions",nl]),
 			gen_record2(Name,'SEQUENCE',Rootl2,"",noext),
@@ -1378,6 +1289,7 @@ gen_head(Erules,Mod,Hrl) ->
     emit({"-module('",Mod,"').",nl}),
     put(currmod,Mod),
     emit({"-compile(nowarn_unused_vars).",nl}),
+    emit({"-dialyzer(no_improper_lists).",nl}),
     case Hrl of
 	0 -> ok;
 	_ -> emit({"-include(\"",Mod,".hrl\").",nl})
@@ -1429,165 +1341,6 @@ to_textual_order(Cs=[#'ComponentType'{textual_order=undefined}|_]) ->
 to_textual_order(Cs) when is_list(Cs) ->
     lists:keysort(#'ComponentType'.textual_order,Cs).
     
-
-gen_check_call(TopType,Cname,Type,InnerType,WhatKind,DefaultValue,Element) ->
-    case WhatKind of
-	{primitive,bif} ->
-	    gen_prim_check_call(InnerType,DefaultValue,Element,Type);
-	#'Externaltypereference'{module=M,type=T} ->
-	    %% generate function call
-	    Name = list2name([T,check]),
-	    emit({"'",Name,"'(",DefaultValue,", ",Element,")"}),
-	    %% insert in ets table and do look ahead check
-	    Typedef = asn1_db:dbget(M,T),
-	    RefType = Typedef#typedef.typespec,
-	    InType = asn1ct_gen:get_inner(RefType#type.def),
-	    case insert_once(check_functions,{Name,RefType}) of
-		true ->
-		    lookahead_innertype([T],InType,RefType);
-		_ ->
-		    ok
-	    end;
-	{constructed,bif} ->
-	    NameList = [Cname|TopType],
-	    Name = list2name(NameList ++ [check]),
-	    emit({"'",Name,"'(",DefaultValue,", ",Element,")"}),
-	    asn1ct_table:insert(check_functions, {Name, Type}),
-	    %% Must look for check functions in InnerType,
-	    %% that may be referenced  or internal defined 
-	    %% constructed types not used elsewhere.
-	    lookahead_innertype(NameList,InnerType,Type);
-	_ ->
-	    %% Generate Dummy function call i.e. anything is accepted
-	    emit(["fun() -> true end ()"])
-    end.
-
-gen_prim_check_call(PrimType, Default, Element, Type) ->
-    case unify_if_string(PrimType) of
-	'BOOLEAN' ->
-	    check_call(check_bool, [Default,Element]);
-	'INTEGER' ->
-	    NNL = case Type#type.def of
-		      {_,NamedNumberList} -> NamedNumberList;
-		      _ -> []
-		  end,
-	    check_call(check_int, [Default,Element,{asis,NNL}]);
-	'BIT STRING' ->
-	    {_,NBL} = Type#type.def,
-	    check_call(check_bitstring, [Default,Element,{asis,NBL}]);
-	'OCTET STRING' ->
-	    check_call(check_octetstring, [Default,Element]);
-	'NULL' ->
-	    check_call(check_null, [Default,Element]);
-	'OBJECT IDENTIFIER' ->
-	    check_call(check_objectidentifier, [Default,Element]);
-	'RELATIVE-OID' ->
-	    check_call(check_objectidentifier, [Default,Element]);
-	'ObjectDescriptor' ->
-	    check_call(check_objectdescriptor, [Default,Element]);
-	'REAL' ->
-	    check_call(check_real, [Default,Element]);
-	'ENUMERATED' ->
-	    {_,Enumerations} = Type#type.def,
-	    check_call(check_enum, [Default,Element,{asis,Enumerations}]);
-	restrictedstring ->
-	    check_call(check_restrictedstring, [Default,Element])
-    end.
-
-check_call(F, Args) ->
-    asn1ct_func:call(check, F, Args).
-
-%% lokahead_innertype/3 traverses Type and checks if check functions
-%% have to be generated, i.e. for all constructed or referenced types.
-lookahead_innertype(Name,'SEQUENCE',Type) ->
-    Components = (Type#type.def)#'SEQUENCE'.components,
-    lookahead_components(Name,Components);
-lookahead_innertype(Name,'SET',Type) ->
-    Components = (Type#type.def)#'SET'.components,
-    lookahead_components(Name,Components);
-lookahead_innertype(Name,'CHOICE',Type) ->
-    {_,Components} = Type#type.def,
-    lookahead_components(Name,Components);
-lookahead_innertype(Name,'SEQUENCE OF',SeqOf) ->
-    lookahead_sof(Name,'SEQOF',SeqOf);
-lookahead_innertype(Name,'SET OF',SeqOf) ->
-    lookahead_sof(Name,'SETOF',SeqOf);
-lookahead_innertype(_Name,#'Externaltypereference'{module=M,type=T},_) ->
-    Typedef = asn1_db:dbget(M,T),
-    RefType = Typedef#typedef.typespec,
-    insert_once(check_functions,{list2name([T,check]),RefType}),
-    InType = asn1ct_gen:get_inner(RefType#type.def),
-    case type(InType) of
-	{constructed,bif} ->
-	    lookahead_innertype([T],InType,RefType);
-	Ref = #'Externaltypereference'{} ->
-	    lookahead_reference(Ref);
-	_ ->
-	    ok
-    end;
-lookahead_innertype(_,_,_) ->
-    ok.
-
-lookahead_components(_,[]) -> ok;
-lookahead_components(Name,[C|Cs]) ->
-    #'ComponentType'{name=Cname,typespec=Type} = C,
-    InType = asn1ct_gen:get_inner(Type#type.def),
-    case asn1ct_gen:type(InType) of
-	{constructed,bif} ->
-	    case insert_once(check_functions,
-			     {list2name([Cname|Name] ++ [check]),Type}) of
-		true ->
-		    lookahead_innertype([Cname|Name],InType,Type);
-		_ ->
-		    ok
-	    end;
-	#'Externaltypereference'{module=RefMod,type=RefName} ->
-  	    Typedef = asn1_db:dbget(RefMod,RefName),
-  	    RefType = Typedef#typedef.typespec,
-  	    case insert_once(check_functions,{list2name([RefName,check]),
-  					      RefType}) of
-  		true ->
-  		    lookahead_innertype([RefName],InType,RefType);
-  		_ ->
-  		    ok
-  	    end;
-	_ ->
-	    ok
-    end,
-    lookahead_components(Name,Cs).
-
-lookahead_sof(Name,SOF,SOFType) ->
-    Type = case SOFType#type.def of
-	       {_,_Type} -> _Type;
-	       _Type -> _Type
-	   end,
-    InnerType = asn1ct_gen:get_inner(Type#type.def),
-    case asn1ct_gen:type(InnerType) of
-	{constructed,bif} ->
-	    %% this is if a constructed type is defined in
-	    %% the SEQUENCE OF type
-	    NameList = [SOF|Name],
-	    insert_once(check_functions,
-			{list2name(NameList ++ [check]),Type}),
-	    lookahead_innertype(NameList,InnerType,Type);
-	Ref = #'Externaltypereference'{} ->
-	    lookahead_reference(Ref);
-	_ ->
-	    ok
-    end.
-
-lookahead_reference(#'Externaltypereference'{module=M,type=T}) ->
-    Typedef = asn1_db:dbget(M,T),
-    RefType = Typedef#typedef.typespec,
-    InType = get_inner(RefType#type.def),
-    case insert_once(check_functions,
-		     {list2name([T,check]),RefType}) of
-	true ->
-	    lookahead_innertype([T],InType,RefType);
-	_ ->
-	    ok
-    end.
-
 insert_once(Table,Object) ->
     case asn1ct_table:lookup(Table, element(1, Object)) of
 	[] ->
@@ -1628,9 +1381,38 @@ unify_if_string(PrimType) ->
 	Other -> Other
     end.
 
+conform_value(#type{def={'BIT STRING',[]}}, Bs) ->
+    case asn1ct:get_bit_string_format() of
+	compact when is_binary(Bs) ->
+	    {0,Bs};
+	compact when is_bitstring(Bs) ->
+	    Sz = bit_size(Bs),
+	    Unused = 8 - bit_size(Bs),
+	    {Unused,<<Bs:Sz/bits,0:Unused>>};
+	legacy ->
+	    [B || <<B:1>> <= Bs];
+	bitstring when is_bitstring(Bs) ->
+	    Bs
+    end;
+conform_value(#type{def='OCTET STRING'}, String) ->
+    case asn1ct:use_legacy_types() of
+	false -> String;
+	true -> binary_to_list(String)
+    end;
+conform_value(_, Value) -> Value.
+
+named_bitstring_value(List, Names) ->
+    Int = lists:foldl(fun(N, A) ->
+			      {N,Pos} = lists:keyfind(N, 1, Names),
+			      A bor (1 bsl Pos)
+		      end, 0, List),
+    named_bitstring_value_1(<<>>, Int).
 
-	
-	
+named_bitstring_value_1(Bs, 0) ->
+    Bs;
+named_bitstring_value_1(Bs, Int) ->
+    B = Int band 1,
+    named_bitstring_value_1(<<Bs/bitstring,B:1>>, Int bsr 1).
 
 get_inner(A) when is_atom(A) -> A;    
 get_inner(Ext) when is_record(Ext,'Externaltypereference') -> Ext;    
@@ -1835,11 +1617,6 @@ get_constraint(C,Key) ->
 	{value,Cnstr} ->
 	    Cnstr
     end.
-
-ensure_atom(Atom) when is_atom(Atom) ->
-    Atom;
-ensure_atom(List) when is_list(List) ->
-    list_to_atom(List).
     
 get_record_name_prefix() ->
     case lists:keysearch(record_name_prefix,1,get(encoding_options)) of
diff --git a/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl b/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl
index 8ab49aec2c..b884d14b0d 100644
--- a/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl
+++ b/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2002-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -24,14 +25,15 @@
 
 -include("asn1_records.hrl").
 
--export([decode_class/1, decode_type/1]).
+-export([decode_class/1]).
 -export([gen_encode/2,gen_encode/3,gen_decode/2,gen_decode/3]).
 -export([gen_encode_prim/4]).
--export([gen_dec_prim/7]).
+-export([gen_dec_prim/3]).
 -export([gen_objectset_code/2, gen_obj_code/3]).
 -export([encode_tag_val/3]).
 -export([gen_inc_decode/2,gen_decode_selected/3]).
 -export([extaddgroup2sequence/1]).
+-export([dialyzer_suppressions/1]).
 
 -import(asn1ct_gen, [emit/1,demit/1]).
 
@@ -65,6 +67,23 @@
 %%===============================================================================
 %%===============================================================================
 
+dialyzer_suppressions(_) ->
+    case asn1ct:use_legacy_types() of
+	false -> ok;
+	true -> suppress({ber,encode_bit_string,4})
+    end,
+    suppress({ber,decode_selective,2}),
+    emit(["    ok.",nl]).
+
+suppress({M,F,A}=MFA) ->
+    case asn1ct_func:is_used(MFA) of
+	false ->
+	    ok;
+	true ->
+	    Args = [lists:concat(["element(",I,", Arg)"]) || I <- lists:seq(1, A)],
+	    emit(["    ",{call,M,F,Args},com,nl])
+    end.
+
 %%===============================================================================
 %% encode #{typedef, {pos, name, typespec}}
 %%===============================================================================
@@ -163,6 +182,12 @@ gen_encode_user(Erules, #typedef{}=D, Wrapper) ->
 
 gen_encode_prim(_Erules, #type{}=D, DoTag, Value) ->
     BitStringConstraint = get_size_constraint(D#type.constraint),
+    MaxBitStrSize = case BitStringConstraint of
+			[] -> none;
+			{_,'MAX'} -> none;
+			{_,Max} -> Max;
+			Max when is_integer(Max) -> Max
+		    end,
     asn1ct_name:new(enumval),
     Type = case D#type.def of
 	       'OCTET STRING'    -> restricted_string;
@@ -196,12 +221,42 @@ gen_encode_prim(_Erules, #type{}=D, DoTag, Value) ->
 	    emit(["case ",Value," of",nl]),
 	    emit_enc_enumerated_cases(NamedNumberList,DoTag);
 	'REAL' ->
-	    emit([{call,ber,encode_tags,
-		   [DoTag,{call,real_common,ber_encode_real,[Value]}]}]);
+	    asn1ct_name:new(realval),
+	    asn1ct_name:new(realsize),
+	    emit(["begin",nl,
+		  {curr,realval}," = ",
+		  {call,real_common,ber_encode_real,[Value]},com,nl,
+		  {curr,realsize}," = ",
+		  {call,erlang,byte_size,[{curr,realval}]},com,nl,
+		  {call,ber,encode_tags,
+		   [DoTag,{curr,realval},{curr,realsize}]},nl,
+		  "end"]);
+	{'BIT STRING',[]} ->
+	    case asn1ct:use_legacy_types() of
+		false when MaxBitStrSize =:= none ->
+		    call(encode_unnamed_bit_string, [Value,DoTag]);
+		false ->
+		    call(encode_unnamed_bit_string,
+			 [{asis,MaxBitStrSize},Value,DoTag]);
+		true ->
+		    call(encode_bit_string,
+			 [{asis,BitStringConstraint},Value,
+			  {asis,[]},DoTag])
+	    end;
 	{'BIT STRING',NamedNumberList} ->
-	    call(encode_bit_string,
-		 [{asis,BitStringConstraint},Value,
-		  {asis,NamedNumberList},DoTag]);
+	    case asn1ct:use_legacy_types() of
+		false when MaxBitStrSize =:= none ->
+		    call(encode_named_bit_string,
+			 [Value,{asis,NamedNumberList},DoTag]);
+		false ->
+		    call(encode_named_bit_string,
+			 [{asis,MaxBitStrSize},Value,
+			  {asis,NamedNumberList},DoTag]);
+		true ->
+		    call(encode_bit_string,
+			 [{asis,BitStringConstraint},Value,
+			  {asis,NamedNumberList},DoTag])
+	    end;
 	'NULL' ->
 	    call(encode_null, [Value,DoTag]);
 	'OBJECT IDENTIFIER' ->
@@ -224,14 +279,34 @@ emit_enc_enumerated_cases(L, Tags) ->
     emit_enc_enumerated_cases(L, Tags, noext).
 
 emit_enc_enumerated_cases([{EnumName,EnumVal}|T], Tags, Ext) ->
+    {Bytes,Len} = encode_integer(EnumVal),
     emit([{asis,EnumName}," -> ",
-	  {call,ber,encode_enumerated,[EnumVal,Tags]},";",nl]),
+	  {call,ber,encode_tags,[Tags,{asis,Bytes},Len]},";",nl]),
     emit_enc_enumerated_cases(T, Tags, Ext);
 emit_enc_enumerated_cases([], _Tags, _Ext) ->
     %% FIXME: Should extension be handled?
     emit([{curr,enumval}," -> exit({error,{asn1, {enumerated_not_in_range,",{curr, enumval},"}}})"]),
     emit([nl,"end"]).
 
+encode_integer(Val) ->
+    Bytes =
+	if
+	    Val >= 0 ->
+		encode_integer_pos(Val, []);
+	    true ->
+		encode_integer_neg(Val, [])
+	end,
+    {Bytes,length(Bytes)}.
+
+encode_integer_pos(0, [B|_Acc]=L) when B < 128 ->
+    L;
+encode_integer_pos(N, Acc) ->
+    encode_integer_pos((N bsr 8), [N band 16#ff| Acc]).
+
+encode_integer_neg(-1, [B1|_T]=L) when B1 > 127 ->
+    L;
+encode_integer_neg(N, Acc) ->
+    encode_integer_neg(N bsr 8, [N band 16#ff|Acc]).
 
 %%===============================================================================
 %%===============================================================================
@@ -309,15 +384,11 @@ gen_decode_selected_type(_Erules,TypeDef) ->
     case asn1ct_gen:type(InnerType) of
 	'ASN1_OPEN_TYPE' ->
 	    asn1ct_name:new(len),
-	    gen_dec_prim(ber, Def#type{def='ASN1_OPEN_TYPE'}, 
-			 BytesVar,Tag, [] , 
-			 ?PRIMITIVE,"OptOrMand");
-%	    emit({";",nl});
+	    gen_dec_prim(Def#type{def='ASN1_OPEN_TYPE'},
+			 BytesVar, Tag);
 	{primitive,bif} ->
 	    asn1ct_name:new(len),
-	    gen_dec_prim(ber, Def, BytesVar,Tag,[] , 
-			 ?PRIMITIVE,"OptOrMand");
-%	    emit([";",nl]);
+	    gen_dec_prim(Def, BytesVar, Tag);
 	{constructed,bif} ->
 	    TopType = case TypeDef#typedef.name of
 			  A when is_atom(A) -> [A];
@@ -431,14 +502,12 @@ gen_decode_user(Erules,D) when is_record(D,typedef) ->
     case asn1ct_gen:type(InnerType) of
 	'ASN1_OPEN_TYPE' ->
 	    asn1ct_name:new(len),
-	    gen_dec_prim(ber, Def#type{def='ASN1_OPEN_TYPE'}, 
-			 BytesVar,{string,"TagIn"}, [] , 
-			 ?PRIMITIVE,"OptOrMand"),
+	    gen_dec_prim(Def#type{def='ASN1_OPEN_TYPE'},
+			 BytesVar, {string,"TagIn"}),
 	    emit({".",nl,nl});
 	{primitive,bif} ->
 	    asn1ct_name:new(len),
-	    gen_dec_prim(ber, Def, BytesVar,{string,"TagIn"},[] , 
-			 ?PRIMITIVE,"OptOrMand"),
+	    gen_dec_prim(Def, BytesVar, {string,"TagIn"}),
 	    emit([".",nl,nl]);
 	{constructed,bif} ->
 	    asn1ct:update_namelist(D#typedef.name),
@@ -451,19 +520,11 @@ gen_decode_user(Erules,D) when is_record(D,typedef) ->
     end.
 
 
-gen_dec_prim(_Erules, Att, BytesVar, DoTag, _TagIn, _Form, _OptOrMand) ->
+gen_dec_prim(Att, BytesVar, DoTag) ->
     Typename = Att#type.def,
-%% Currently not used for BER replaced with [] as place holder
-%%    Constraint = Att#type.constraint,
-%% Constraint = [],
     Constraint = get_size_constraint(Att#type.constraint),
     IntConstr = int_constr(Att#type.constraint),
-    AsBin = case get(binary_strings) of
-		true -> "_as_bin";
-		_ -> ""
-	    end,
     NewTypeName = case Typename of
-		      'OCTET STRING'    -> restricted_string;
 		      'NumericString'   -> restricted_string;
 		      'TeletexString'   -> restricted_string;
 		      'T61String'       -> restricted_string;
@@ -476,85 +537,40 @@ gen_dec_prim(_Erules, Att, BytesVar, DoTag, _TagIn, _Form, _OptOrMand) ->
 		      'ObjectDescriptor'-> restricted_string;
 		      'UTCTime'         -> restricted_string;
 		      'GeneralizedTime' -> restricted_string;
+		      'OCTET STRING'    ->
+			  case asn1ct:use_legacy_types() of
+			      true -> restricted_string;
+			      false -> Typename
+			  end;
 		      _                 -> Typename
 		  end,
-    case NewTypeName of
-	'BOOLEAN'->
-	    emit(["decode_boolean(",BytesVar,","]),
-	    need(decode_boolean, 2);
-	'INTEGER' ->
-	    case IntConstr of
-		[] ->
-		    emit(["decode_integer(",BytesVar,","]),
-		    need(decode_integer, 2);
-		{_,_} ->
-		    emit(["decode_integer(",BytesVar,",",
-			  {asis,IntConstr},","]),
-		    need(decode_integer, 3)
-	    end;
-	{'INTEGER',NamedNumberList} ->
-	    case IntConstr of
-		[] ->
-		    emit(["decode_named_integer(",BytesVar,",",
-			  {asis,NamedNumberList},","]),
-		    need(decode_named_integer, 3);
-		{_,_} ->
-		    emit(["decode_named_integer(",BytesVar,",",
-			  {asis,IntConstr},",",
-			  {asis,NamedNumberList},","]),
-		    need(decode_named_integer, 4)
-	    end;
-	{'ENUMERATED',NamedNumberList} ->
-	    emit(["decode_enumerated(",BytesVar,",",
-		  {asis,NamedNumberList},","]),
-	    need(decode_enumerated, 3);
-	'REAL' ->
-	    ok;
-	{'BIT STRING',_NamedNumberList} ->
-	    ok;
-	'NULL' ->
-	    emit(["decode_null(",BytesVar,","]),
-	    need(decode_null, 2);
-	'OBJECT IDENTIFIER' ->
-	    emit(["decode_object_identifier(",BytesVar,","]),
-	    need(decode_object_identifier, 2);
-	'RELATIVE-OID' ->
-	    emit(["decode_relative_oid(",BytesVar,","]),
-	    need(decode_relative_oid, 2);
-	restricted_string ->
-	    emit(["decode_restricted_string",AsBin,"(",BytesVar,","]),
-	    case Constraint of
-		[] ->
-		    need(decode_restricted_string, 2);
-		_ ->
-		    emit([{asis,Constraint},","]),
-		    need(decode_restricted_string, 3)
-	    end;
-	'UniversalString' ->
-	    emit(["decode_universal_string",AsBin,"(",
-		  BytesVar,",",{asis,Constraint},","]),
-	    need(decode_universal_string, 3);
-	'UTF8String' ->
-	    emit(["decode_UTF8_string",AsBin,"(",
-		  BytesVar,","]),
-	    need(decode_UTF8_string, 2);
-	'BMPString' ->
-	    emit(["decode_BMP_string",AsBin,"(",
-		  BytesVar,",",{asis,Constraint},","]),
-	    need(decode_BMP_string, 3);
-	'ASN1_OPEN_TYPE' ->
-	    emit(["decode_open_type_as_binary(",
-		  BytesVar,","]),
-	    need(decode_open_type_as_binary, 2)
-    end,
-
     TagStr = case DoTag of
 		 {string,Tag1} -> Tag1;
 		 _ when is_list(DoTag) -> {asis,DoTag}
 	     end,
     case NewTypeName of
-	{'BIT STRING',NNL} ->
-	    gen_dec_bit_string(BytesVar, Constraint, NNL, TagStr);
+	'BOOLEAN'->
+	    call(decode_boolean, [BytesVar,TagStr]);
+	'INTEGER' ->
+	    check_constraint(decode_integer, [BytesVar,TagStr],
+			     IntConstr,
+			     identity,
+			     identity);
+	{'INTEGER',NNL} ->
+	    check_constraint(decode_integer,
+			     [BytesVar,TagStr],
+			     IntConstr,
+			     identity,
+			     fun(Val) ->
+				     asn1ct_name:new(val),
+				     emit([{curr,val}," = "]),
+				     Val(),
+				     emit([com,nl,
+					   {call,ber,number2name,
+					    [{curr,val},{asis,NNL}]}])
+			     end);
+	{'ENUMERATED',NNL} ->
+	    gen_dec_enumerated(BytesVar, NNL, TagStr);
 	'REAL' ->
 	    asn1ct_name:new(tmpbuf),
 	    emit(["begin",nl,
@@ -562,8 +578,36 @@ gen_dec_prim(_Erules, Att, BytesVar, DoTag, _TagIn, _Form, _OptOrMand) ->
 		  {call,ber,match_tags,[BytesVar,TagStr]},com,nl,
 		  {call,real_common,decode_real,[{curr,tmpbuf}]},nl,
 		  "end",nl]);
-	_ ->
-	    emit([TagStr,")"])
+	{'BIT STRING',NNL} ->
+	    gen_dec_bit_string(BytesVar, Constraint, NNL, TagStr);
+	'NULL' ->
+	    call(decode_null, [BytesVar,TagStr]);
+	'OBJECT IDENTIFIER' ->
+	    call(decode_object_identifier, [BytesVar,TagStr]);
+	'RELATIVE-OID' ->
+	    call(decode_relative_oid, [BytesVar,TagStr]);
+	'OCTET STRING' ->
+	    check_constraint(decode_octet_string, [BytesVar,TagStr],
+			     Constraint, {erlang,byte_size}, identity);
+	restricted_string ->
+	    check_constraint(decode_restricted_string, [BytesVar,TagStr],
+			     Constraint,
+			     {erlang,byte_size},
+			     fun(Val) ->
+				     emit("binary_to_list("),
+				     Val(),
+				     emit(")")
+			     end);
+	'UniversalString' ->
+	    check_constraint(decode_universal_string, [BytesVar,TagStr],
+			     Constraint, {erlang,length}, identity);
+	'UTF8String' ->
+	    call(decode_UTF8_string, [BytesVar,TagStr]);
+	'BMPString' ->
+	    check_constraint(decode_BMP_string, [BytesVar,TagStr],
+			     Constraint, {erlang,length}, identity);
+	'ASN1_OPEN_TYPE' ->
+	    call(decode_open_type_as_binary, [BytesVar,TagStr])
     end.
 
 %% Simplify an integer constraint so that we can efficiently test it.
@@ -579,7 +623,7 @@ int_constr(C) ->
 	[{'ValueRange',{_,_}=Range}] ->
 	    Range;
 	[{'SingleValue',Sv}] ->
-	    {Sv,Sv};
+	    Sv;
 	[] ->
 	    []
     end.
@@ -590,16 +634,108 @@ gen_dec_bit_string(BytesVar, _Constraint, [_|_]=NNL, TagStr) ->
 gen_dec_bit_string(BytesVar, Constraint, [], TagStr) ->
     case asn1ct:get_bit_string_format() of
 	compact ->
-	    call(decode_compact_bit_string,
-		 [BytesVar,{asis,Constraint},TagStr]);
+	    check_constraint(decode_compact_bit_string,
+			     [BytesVar,TagStr],
+			     Constraint,
+			     {ber,compact_bit_string_size},
+			     identity);
 	legacy ->
-	    call(decode_legacy_bit_string,
-		 [BytesVar,{asis,Constraint},TagStr]);
+	    check_constraint(decode_native_bit_string,
+			     [BytesVar,TagStr],
+			     Constraint,
+			     {erlang,bit_size},
+			     fun(Val) ->
+				     asn1ct_name:new(val),
+				     emit([{curr,val}," = "]),
+				     Val(),
+				     emit([com,nl,
+					   {call,ber,native_to_legacy_bit_string,
+					    [{curr,val}]}])
+			     end);
 	bitstring ->
-	    call(decode_native_bit_string,
-		 [BytesVar,{asis,Constraint},TagStr])
+	    check_constraint(decode_native_bit_string,
+			     [BytesVar,TagStr],
+			     Constraint,
+			     {erlang,bit_size},
+			     identity)
+    end.
+
+check_constraint(F, Args, Constr, PreConstr0, ReturnVal0) ->
+    PreConstr = case PreConstr0 of
+		    identity ->
+			fun(V) -> V end;
+		    {Mod,Name} ->
+			fun(V) ->
+				asn1ct_name:new(c),
+				emit([{curr,c}," = ",
+				      {call,Mod,Name,[V]},com,nl]),
+				{curr,c}
+			end
+		end,
+    ReturnVal = case ReturnVal0 of
+		    identity ->	fun(Val) -> Val() end;
+		    _ -> ReturnVal0
+		end,
+    case Constr of
+	[] when ReturnVal0 =:= identity ->
+	    %% No constraint, no complications.
+	    call(F, Args);
+	[] ->
+	    %% No constraint, but the return value could consist
+	    %% of more than one statement.
+	    emit(["begin",nl]),
+	    ReturnVal(fun() -> call(F, Args) end),
+	    emit([nl,
+		  "end",nl]);
+	_ ->
+	    %% There is a constraint.
+	    asn1ct_name:new(val),
+	    emit(["begin",nl,
+		  {curr,val}," = ",{call,ber,F,Args},com,nl]),
+	    PreVal0 = asn1ct_gen:mk_var(asn1ct_name:curr(val)),
+	    PreVal = PreConstr(PreVal0),
+	    emit("if "),
+	    case Constr of
+		{Min,Max} ->
+		    emit([{asis,Min}," =< ",PreVal,", ",
+			  PreVal," =< ",{asis,Max}]);
+		Sv when is_integer(Sv) ->
+		    emit([PreVal," =:= ",{asis,Sv}])
+	    end,
+	    emit([" ->",nl]),
+	    ReturnVal(fun() -> emit(PreVal0) end),
+	    emit([";",nl,
+		  "true ->",nl,
+		  "exit({error,{asn1,bad_range}})",nl,
+		  "end",nl,
+		 "end"])
     end.
 
+gen_dec_enumerated(BytesVar, NNL0, TagStr) ->
+    asn1ct_name:new(enum),
+    emit(["case ",
+	  {call,ber,decode_integer,[BytesVar,TagStr]},
+	  " of",nl]),
+    NNL = case NNL0 of
+	      {L1,L2} ->
+		  L1 ++ L2 ++ [accept];
+	      [_|_] ->
+		  NNL0 ++ [error]
+	  end,
+    gen_dec_enumerated_1(NNL),
+    emit("end").
+
+gen_dec_enumerated_1([accept]) ->
+    asn1ct_name:new(default),
+    emit([{curr,default}," -> {asn1_enum,",{curr,default},"}",nl]);
+gen_dec_enumerated_1([error]) ->
+    asn1ct_name:new(default),
+    emit([{curr,default}," -> exit({error,{asn1,{illegal_enumerated,",
+	  {curr,default},"}}})",nl]);
+gen_dec_enumerated_1([{V,K}|T]) ->
+    emit([{asis,K}," -> ",{asis,V},";",nl]),
+    gen_dec_enumerated_1(T).
+
     
 %% Object code generating for encoding and decoding
 %% ------------------------------------------------
@@ -637,9 +773,6 @@ gen_encode_objectfields(ClassName,[{typefield,Name,OptOrMand}|Rest],
 % 	  ", Val, RestPrimFieldName) ->",nl]),
     MaybeConstr=
 	case {get_object_field(Name,ObjectFields),OptOrMand} of
-	    {false,'MANDATORY'} -> %% this case is illegal
-		exit({error,{asn1,{"missing mandatory field in object",
-				   ObjName}}});
 	    {false,'OPTIONAL'} ->
 		EmitFuncClause("Val"),
 		emit(["   {Val,0}"]),
@@ -672,9 +805,6 @@ gen_encode_objectfields(ClassName,[{objectfield,Name,_,_,OptOrMand}|Rest],
 %     emit(["'enc_",ObjName,"'(",{asis,Name},
 % 	  ", Val,[H|T]) ->",nl]),
     case {get_object_field(Name,ObjectFields),OptOrMand} of
-	{false,'MANDATORY'} ->
-	    exit({error,{asn1,{"missing mandatory field in object",
-			       ObjName}}});
 	{false,'OPTIONAL'} ->
 	    EmitFuncClause("_,_"),
 	    emit(["  exit({error,{'use of missing field in object', ",{asis,Name},
@@ -807,9 +937,6 @@ gen_decode_objectfields(ClassName,[{typefield,Name,OptOrMand}|Rest],
 % 	  ", Bytes, RestPrimFieldName) ->",nl]),
     MaybeConstr=
 	case {get_object_field(Name,ObjectFields),OptOrMand} of
-	    {false,'MANDATORY'} -> %% this case is illegal
-		exit({error,{asn1,{"missing mandatory field in object",
-				   ObjName}}});
 	    {false,'OPTIONAL'} ->
 		EmitFuncClause(" Bytes"),
 		emit(["   Bytes"]),
@@ -844,9 +971,6 @@ gen_decode_objectfields(ClassName,[{objectfield,Name,_,_,OptOrMand}|Rest],
 % 	  ", Bytes,[H|T]) ->",nl]),
 %     emit_tlv_format("Bytes"),
     case {get_object_field(Name,ObjectFields),OptOrMand} of
-	{false,'MANDATORY'} ->
-	    exit({error,{asn1,{"missing mandatory field in object",
-			       ObjName}}});
 	{false,'OPTIONAL'} ->
 	    EmitFuncClause("_,_"),
 	    emit(["  exit({error,{'illegal use of missing field in object', ",{asis,Name},
@@ -956,9 +1080,8 @@ gen_decode_field_call(ObjName,FieldName,Bytes,Type) ->
     Tag = [(decode_class(X#tag.class) bsl 10) + X#tag.number || 
 	      X <- OTag],
     case Type#typedef.name of
-	{primitive,bif} -> %%tag should be the primitive tag
-	    gen_dec_prim(ber,Def,Bytes,Tag,"TagIn",?PRIMITIVE,
-			 opt_or_default),
+	{primitive,bif} ->
+	    gen_dec_prim(Def, Bytes, Tag),
 	    [];
 	{constructed,bif} ->
 	    emit({"   'dec_",ObjName,'_',FieldName,
@@ -986,8 +1109,7 @@ gen_decode_default_call(ClassName,FieldName,Bytes,Type) ->
 						      FieldName])),
 		      typespec=Type}];
 	{primitive,bif} ->
-	    gen_dec_prim(ber,Type,Bytes,Tag,"TagIn",
-			 ?PRIMITIVE,opt_or_default),
+	    gen_dec_prim(Type, Bytes, Tag),
 	    [];
 	#'Externaltypereference'{module=CurrentMod,type=Etype} ->
 	    emit(["   'dec_",Etype,"'(",Bytes, " ,",{asis,Tag},")",nl]),
@@ -1072,36 +1194,35 @@ gen_objset_enc(_,_,{unique,undefined},_,_,_,_,_) ->
 gen_objset_enc(Erules, ObjSetName, UniqueName,
 	       [{ObjName,Val,Fields}|T], ClName, ClFields,
 	       NthObj,Acc)->
-    emit(["'getenc_",ObjSetName,"'(",{asis,UniqueName},",",{asis,Val},
-	  ") ->",nl]),
     CurrMod = get(currmod),
     {InternalFunc,NewNthObj}=
 	case ObjName of
 	    {no_mod,no_name} ->
-		gen_inlined_enc_funs(Fields,ClFields,ObjSetName,NthObj);
+		gen_inlined_enc_funs(Fields, ClFields, ObjSetName, Val, NthObj);
 	    {CurrMod,Name} ->
-		emit({"    fun 'enc_",Name,"'/3"}),
+		emit(["'getenc_",ObjSetName,"'(",{asis,Val},") ->",nl,
+		      "    fun 'enc_",Name,"'/3;",nl]),
 		{[],NthObj};
 	    {ModuleName,Name} ->
+		emit(["'getenc_",ObjSetName,"'(",{asis,Val},") ->",nl]),
 		emit_ext_fun(enc,ModuleName,Name),
+		emit([";",nl]),
 		{[],NthObj};
 	    _ ->
-		emit({"    fun 'enc_",ObjName,"'/3"}),
+		emit(["'getenc_",ObjSetName,"'(",{asis,Val},") ->",nl,
+		      "    fun 'enc_",ObjName,"'/3;",nl]),
 		{[],NthObj}
 	end,
-    emit({";",nl}),
     gen_objset_enc(Erules, ObjSetName, UniqueName, T, ClName, ClFields,
 		   NewNthObj, InternalFunc ++ Acc);
 %% See X.681 Annex E for the following case
 gen_objset_enc(_,ObjSetName,_UniqueName,['EXTENSIONMARK'],_ClName,
 	       _ClFields,_NthObj,Acc) ->
-    emit({"'getenc_",ObjSetName,"'(_, _) ->",nl}),
-    emit({indent(3),"fun(_, Val, _RestPrimFieldName) ->",nl}),
-    emit({indent(6),"Len = case Val of",nl,indent(9),
-	  "Bin when is_binary(Bin) -> byte_size(Bin);",nl,indent(9),
- 	  "_ -> length(Val)",nl,indent(6),"end,"}),
-    emit({indent(6),"{Val,Len}",nl}),
-    emit({indent(3),"end.",nl,nl}),
+    emit(["'getenc_",ObjSetName,"'(_) ->",nl,
+	  indent(2),"fun(_, Val, _RestPrimFieldName) ->",nl]),
+    emit_enc_open_type(4),
+    emit([nl,
+	  indent(2),"end.",nl,nl]),
     Acc;
 gen_objset_enc(_, ObjSetName, UniqueName, [], _, _, _, Acc) ->
     emit_default_getenc(ObjSetName, UniqueName),
@@ -1113,19 +1234,20 @@ emit_ext_fun(EncDec,ModuleName,Name) ->
 	  Name,"'(T,V,O) end"]).
     
 emit_default_getenc(ObjSetName,UniqueName) ->
-    emit(["'getenc_",ObjSetName,"'(",{asis,UniqueName},", ErrV) ->",nl]),
+    emit(["'getenc_",ObjSetName,"'(ErrV) ->",nl]),
     emit([indent(3),"fun(C,V,_) -> exit({'Type not compatible with table constraint',{component,C},{value,V}, {unique_name_and_value,",{asis,UniqueName},", ErrV}}) end"]).
 
 %% gen_inlined_enc_funs for each object iterates over all fields of a
 %% class, and for each typefield it checks if the object has that
 %% field and emits the proper code.
-gen_inlined_enc_funs(Fields, [{typefield,_,_}|_]=T, ObjSetName, NthObj) ->
-    emit([indent(3),"fun(Type, Val, _RestPrimFieldName) ->",nl,
+gen_inlined_enc_funs(Fields, [{typefield,_,_}|_]=T, ObjSetName, Val, NthObj) ->
+    emit(["'getenc_",ObjSetName,"'(",{asis,Val},") ->",nl,
+	  indent(3),"fun(Type, Val, _RestPrimFieldName) ->",nl,
 	  indent(6),"case Type of",nl]),
     gen_inlined_enc_funs1(Fields, T, ObjSetName, [], NthObj, []);
-gen_inlined_enc_funs(Fields,[_|Rest],ObjSetName,NthObj) ->
-    gen_inlined_enc_funs(Fields,Rest,ObjSetName,NthObj);
-gen_inlined_enc_funs(_,[],_,NthObj) ->
+gen_inlined_enc_funs(Fields, [_|Rest], ObjSetName, Val, NthObj) ->
+    gen_inlined_enc_funs(Fields, Rest, ObjSetName, Val, NthObj);
+gen_inlined_enc_funs(_, [], _, _, NthObj) ->
     {[],NthObj}.
 
 gen_inlined_enc_funs1(Fields, [{typefield,Name,_}|Rest], ObjSetName,
@@ -1163,13 +1285,8 @@ gen_inlined_enc_funs1(Fields, [{typefield,Name,_}|Rest], ObjSetName,
 		%% were no type in the table and we therefore generate
 		%% code that returns the input for application
 		%% treatment.
-		emit([indent(9),{asis,Name}," ->",nl,
-		      indent(12),"Len = case Val of",nl,
-		      indent(15),"Bin when is_binary(Bin) -> "
-		      "byte_size(Bin);",nl,
-		      indent(15),"_ -> length(Val)",nl,
-		      indent(12),"end,",nl,
-		      indent(12),"{Val,Len}"]),
+		emit([indent(9),{asis,Name}," ->",nl]),
+		emit_enc_open_type(11),
 		{Acc0,0}
 	end,
     gen_inlined_enc_funs1(Fields, Rest, ObjSetName, Sep, NthObj+NAdd, Acc);
@@ -1177,9 +1294,28 @@ gen_inlined_enc_funs1(Fields,[_|Rest], ObjSetName, Sep, NthObj, Acc)->
     gen_inlined_enc_funs1(Fields, Rest, ObjSetName, Sep, NthObj, Acc);
 gen_inlined_enc_funs1(_, [], _, _, NthObj, Acc) ->
     emit([nl,indent(6),"end",nl,
-	  indent(3),"end"]),
+	  indent(3),"end;",nl]),
     {Acc,NthObj}.
 
+emit_enc_open_type(I) ->
+    Indent = indent(I),
+    S = [Indent,          "case Val of",nl,
+	 Indent,indent(2),"{asn1_OPENTYPE,Bin} when is_binary(Bin) ->",nl,
+	 Indent,indent(4),"{Bin,byte_size(Bin)}"|
+	 case asn1ct:use_legacy_types() of
+	     false ->
+		 [nl,
+		  Indent,"end"];
+	     true ->
+		 [";",nl,
+		  Indent,indent(2),"Bin when is_binary(Bin) ->",nl,
+		  Indent,indent(4),"{Bin,byte_size(Bin)};",nl,
+		  Indent,indent(2),"_ ->",nl,
+		  Indent,indent(4),"{Val,length(Val)}",nl,
+		  Indent,          "end"]
+	 end],
+    emit(S).
+
 emit_inner_of_fun(TDef=#typedef{name={ExtMod,Name},typespec=Type},
 		  InternalDefFunName) ->
     OTag = Type#type.tag,
@@ -1240,38 +1376,34 @@ gen_objset_dec(_,_,{unique,undefined},_,_,_,_) ->
     ok;
 gen_objset_dec(Erules, ObjSName, UniqueName, [{ObjName,Val,Fields}|T],
 	       ClName, ClFields, NthObj)->
-    emit(["'getdec_",ObjSName,"'(",{asis,UniqueName},",",
-	  {asis,Val},") ->",nl]),
     CurrMod = get(currmod),
     NewNthObj=
 	case ObjName of
 	    {no_mod,no_name} ->
-		gen_inlined_dec_funs(Fields,ClFields,ObjSName,NthObj);
+		gen_inlined_dec_funs(Fields,ClFields,ObjSName,Val,NthObj);
 	    {CurrMod,Name} ->
-		emit(["    fun 'dec_",Name,"'/3"]),
+		emit(["'getdec_",ObjSName,"'(",{asis,Val},") ->",nl,
+		      "    fun 'dec_",Name,"'/3;", nl]),
 		NthObj;
 	    {ModuleName,Name} ->
+		emit(["'getdec_",ObjSName,"'(",{asis,Val},") ->",nl]),
 		emit_ext_fun(dec,ModuleName,Name),
+		emit([";",nl]),
 		NthObj;
 	    _ ->
-		emit(["    fun 'dec_",ObjName,"'/3"]),
+		emit(["'getdec_",ObjSName,"'(",{asis,Val},") ->",nl,
+		      "    fun 'dec_",ObjName,"'/3;", nl]),
 		NthObj
 	end,
-    emit([";",nl]),
     gen_objset_dec(Erules, ObjSName, UniqueName, T, ClName,
 		   ClFields, NewNthObj);
 gen_objset_dec(_,ObjSetName,_UniqueName,['EXTENSIONMARK'],_ClName,
 	       _ClFields,_NthObj) ->
-    emit(["'getdec_",ObjSetName,"'(_, _) ->",nl]),
+    emit(["'getdec_",ObjSetName,"'(_) ->",nl]),
     emit([indent(2),"fun(_,Bytes, _RestPrimFieldName) ->",nl]),
-    
-    emit([indent(4),"case Bytes of",nl,
-	  indent(6),"Bin when is_binary(Bin) -> ",nl,
-	  indent(8),"Bin;",nl,
-	  indent(6),"_ ->",nl,
-	  indent(8),{call,ber,ber_encode,["Bytes"]},nl,
-	  indent(4),"end",nl]),
-    emit([indent(2),"end.",nl,nl]),
+    emit_dec_open_type(4),
+    emit([nl,
+	  indent(2),"end.",nl,nl]),
     ok;
 gen_objset_dec(_, ObjSetName, UniqueName, [], _, _, _) ->
     emit_default_getdec(ObjSetName, UniqueName),
@@ -1279,13 +1411,18 @@ gen_objset_dec(_, ObjSetName, UniqueName, [], _, _, _) ->
     ok.
 
 emit_default_getdec(ObjSetName,UniqueName) ->
-    emit(["'getdec_",ObjSetName,"'(",{asis,UniqueName},", ErrV) ->",nl]),
+    emit(["'getdec_",ObjSetName,"'(ErrV) ->",nl]),
     emit([indent(2), "fun(C,V,_) -> exit({{component,C},{value,V},{unique_name_and_value,",{asis,UniqueName},", ErrV}}) end"]).
 
-gen_inlined_dec_funs(Fields, ClFields, ObjSetName, NthObj) ->
+gen_inlined_dec_funs(Fields, [{typefield,_,_}|_]=ClFields, ObjSetName, Val, NthObj) ->
+    emit(["'getdec_",ObjSetName,"'(",{asis,Val},") ->",nl]),
     emit([indent(3),"fun(Type, Bytes, _RestPrimFieldName) ->",nl,
 	  indent(6),"case Type of",nl]),
-    gen_inlined_dec_funs1(Fields, ClFields, ObjSetName, "", NthObj).
+    gen_inlined_dec_funs1(Fields, ClFields, ObjSetName, "", NthObj);
+gen_inlined_dec_funs(Fields, [_|ClFields], ObjSetName, Val, NthObj) ->
+    gen_inlined_dec_funs(Fields, ClFields, ObjSetName, Val, NthObj);
+gen_inlined_dec_funs(_, _, _, _,NthObj) ->
+    NthObj.
 
 gen_inlined_dec_funs1(Fields, [{typefield,Name,Prop}|Rest],
 		      ObjSetName, Sep0, NthObj) ->
@@ -1318,12 +1455,8 @@ gen_inlined_dec_funs1(Fields, [{typefield,Name,Prop}|Rest],
 		end,
 		0;
 	    false ->
-		emit([indent(9),{asis,Name}," ->",nl,
-		      indent(12),"Len = case Bytes of",nl,
-		      indent(15),"B when is_binary(B) -> byte_size(B);",nl,
-		      indent(15),"_ -> length(Bytes)",nl,
-		      indent(12),"end,",nl,
-		      indent(12),"{Bytes,[],Len}"]),
+		emit([indent(9),{asis,Name}," ->",nl]),
+		emit_dec_open_type(11),
 		0
     end,
     gen_inlined_dec_funs1(Fields, Rest, ObjSetName, Sep, NthObj+N);
@@ -1331,10 +1464,31 @@ gen_inlined_dec_funs1(Fields, [_|Rest], ObjSetName, Sep, NthObj)->
     gen_inlined_dec_funs1(Fields, Rest, ObjSetName, Sep, NthObj);
 gen_inlined_dec_funs1(_, [], _, _, NthObj) ->
     emit([nl,indent(6),"end",nl,
-	  indent(3),"end"]),
+	  indent(3),"end;",nl]),
     NthObj.
 
-emit_inner_of_decfun(#typedef{name={ExtName,Name},typespec=Type},Prop,
+emit_dec_open_type(I) ->
+    Indent = indent(I),
+    S = case asn1ct:use_legacy_types() of
+	    false ->
+		[Indent,          "case Bytes of",nl,
+		 Indent,indent(2),"Bin when is_binary(Bin) -> ",nl,
+		 Indent,indent(4),"{asn1_OPENTYPE,Bin};",nl,
+		 Indent,indent(2),"_ ->",nl,
+		 Indent,indent(4),"{asn1_OPENTYPE,",
+		 {call,ber,ber_encode,["Bytes"]},"}",nl,
+		 Indent,          "end"];
+	    true ->
+		[Indent,          "case Bytes of",nl,
+		 Indent,indent(2),"Bin when is_binary(Bin) -> ",nl,
+		 Indent,indent(4),"Bin;",nl,
+		 Indent,indent(2),"_ ->",nl,
+		 Indent,indent(4),{call,ber,ber_encode,["Bytes"]},nl,
+		 Indent,          "end"]
+	end,
+    emit(S).
+
+emit_inner_of_decfun(#typedef{name={ExtName,Name},typespec=Type}, _Prop,
 		     InternalDefFunName) ->
     OTag = Type#type.tag,
 %%    Tag = [X#tag{class=decode_class(X#tag.class)}|| X <- OTag],
@@ -1342,8 +1496,7 @@ emit_inner_of_decfun(#typedef{name={ExtName,Name},typespec=Type},Prop,
     case {ExtName,Name} of
 	{primitive,bif} ->
 	    emit(indent(12)),
-	    gen_dec_prim(ber,Type,"Bytes",Tag,"TagIn",
-			 ?PRIMITIVE,Prop),
+	    gen_dec_prim(Type, "Bytes", Tag),
 	    0;
 	{constructed,bif} ->
 	    emit([indent(12),"'dec_",
@@ -1360,7 +1513,7 @@ emit_inner_of_decfun(#typedef{name={ExtName,Name},typespec=Type},Prop,
 emit_inner_of_decfun(#typedef{name=Name},_Prop,_) ->
     emit([indent(12),"'dec_",Name,"'(Bytes)"]),
     0;
-emit_inner_of_decfun(Type,Prop,_) when is_record(Type,type) ->
+emit_inner_of_decfun(#type{}=Type, _Prop, _) ->
     OTag = Type#type.tag,
 %%    Tag = [X#tag{class=decode_class(X#tag.class)}|| X <- OTag],
     Tag = [(decode_class(X#tag.class) bsl 10) + X#tag.number || X <- OTag],
@@ -1371,8 +1524,7 @@ emit_inner_of_decfun(Type,Prop,_) when is_record(Type,type) ->
     case WhatKind of
 	{primitive,bif} -> 
 	    emit([indent(9),Def," ->",nl,indent(12)]),
-	    gen_dec_prim(ber,Type,"Bytes",Tag,"TagIn",
-			 ?PRIMITIVE,Prop);
+	    gen_dec_prim(Type, "Bytes", Tag);
 	#'Externaltypereference'{module=CurrMod,type=T} ->
 	    emit([indent(9),T," ->",nl,indent(12),"'dec_",T,
 %		  "'(Bytes, ",Prop,")"]);
@@ -1407,39 +1559,6 @@ decode_class('CONTEXT') ->
 decode_class('PRIVATE') ->
     ?PRIVATE.
 
-decode_type('BOOLEAN') -> 1;
-decode_type('INTEGER') -> 2;
-decode_type('BIT STRING') -> 3; 
-decode_type('OCTET STRING') -> 4; 
-decode_type('NULL') -> 5;
-decode_type('OBJECT IDENTIFIER') -> 6;
-decode_type('ObjectDescriptor') -> 7;
-decode_type('EXTERNAL') -> 8;
-decode_type('REAL') -> 9;
-decode_type('ENUMERATED') -> 10;
-decode_type('EMBEDDED_PDV') -> 11;
-decode_type('UTF8String') -> 12;
-decode_type('RELATIVE-OID') -> 13;
-decode_type('SEQUENCE') -> 16;
-decode_type('SEQUENCE OF') -> 16;
-decode_type('SET') -> 17;
-decode_type('SET OF') -> 17;
-decode_type('NumericString') -> 18;  
-decode_type('PrintableString') -> 19;  
-decode_type('TeletexString') -> 20;  
-decode_type('T61String') -> 20;
-decode_type('VideotexString') -> 21;  
-decode_type('IA5String') -> 22;  
-decode_type('UTCTime') -> 23;  
-decode_type('GeneralizedTime') -> 24;  
-decode_type('GraphicString') -> 25;  
-decode_type('VisibleString') -> 26;  
-decode_type('GeneralString') -> 27;  
-decode_type('UniversalString') -> 28;  
-decode_type('BMPString') -> 30;
-decode_type('CHOICE') -> 'CHOICE'; % choice gets the tag from the actual alternative  
-decode_type(Else) -> exit({error,{asn1,{unrecognized_type,Else}}}).
-
 mkfuncname(#'Externaltypereference'{module=Mod,type=EType}, DecOrEnc) ->
     CurrMod = get(currmod),
     case CurrMod of
@@ -1509,6 +1628,3 @@ extaddgroup2sequence(ExtList) when is_list(ExtList) ->
 
 call(F, Args) ->
     asn1ct_func:call(ber, F, Args).
-
-need(F, Arity) ->
-    asn1ct_func:need({ber,F,Arity}).
diff --git a/lib/asn1/src/asn1ct_gen_check.erl b/lib/asn1/src/asn1ct_gen_check.erl
new file mode 100644
index 0000000000..abe77dd0cb
--- /dev/null
+++ b/lib/asn1/src/asn1ct_gen_check.erl
@@ -0,0 +1,272 @@
+%% vim: tabstop=8:shiftwidth=4
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2014-2016. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+%%
+
+-module(asn1ct_gen_check).
+-export([emit/3]).
+
+-import(asn1ct_gen, [emit/1]).
+-include("asn1_records.hrl").
+
+emit(Type, Default, Value) ->
+    Key = {Type,Default},
+    Gen = fun(Fd, Name) ->
+		  file:write(Fd, gen(Name, Type, Default))
+	  end,
+    emit(" case "),
+    asn1ct_func:call_gen("is_default_", Key, Gen, [Value]),
+    emit([" of",nl,
+	  "true -> {[],0};",nl,
+	  "false ->",nl]).
+
+gen(Name, #type{def=T}, Default) ->
+    NameStr = atom_to_list(Name),
+    [NameStr,"(asn1_DEFAULT) ->\n",
+     "true;\n"|case do_gen(T, Default) of
+		   {literal,Literal} ->
+		       [NameStr,"(",term2str(Literal),") ->\n","true;\n",
+			NameStr,"(_) ->\n","false.\n\n"];
+		   {exception,Func,Args} ->
+		       [NameStr,"(Value) ->\n",
+			"try ",Func,"(Value",arg2str(Args),") of\n",
+			"_ -> true\n"
+			"catch throw:false -> false\n"
+			"end.\n\n"]
+	       end].
+
+do_gen(_, asn1_NOVALUE) ->
+    {literal,asn1_NOVALUE};
+do_gen(#'Externaltypereference'{module=M,type=T}, Default) ->
+    #typedef{typespec=#type{def=Td}} = asn1_db:dbget(M, T),
+    do_gen(Td, Default);
+do_gen('BOOLEAN', Default) ->
+    {literal,Default};
+do_gen({'BIT STRING',[]}, Default) ->
+    true = is_bitstring(Default),		%Assertion.
+    case asn1ct:use_legacy_types() of
+	false ->
+	    {literal,Default};
+	true ->
+	    {exception,need(check_legacy_bitstring, 2),[Default]}
+    end;
+do_gen({'BIT STRING',[_|_]=NBL}, Default) ->
+    do_named_bitstring(NBL, Default);
+do_gen({'ENUMERATED',_}, Default) ->
+    {literal,Default};
+do_gen('INTEGER', Default) ->
+    {literal,Default};
+do_gen({'INTEGER',NNL}, Default) ->
+    {exception,need(check_int, 3),[Default,NNL]};
+do_gen('NULL', Default) ->
+    {literal,Default};
+do_gen('OCTET STRING', Default) ->
+    true = is_binary(Default),			%Assertion.
+    case asn1ct:use_legacy_types() of
+	false ->
+	    {literal,Default};
+	true ->
+	    {exception,need(check_octetstring, 2),[Default]}
+    end;
+do_gen('OBJECT IDENTIFIER', Default0) ->
+    Default = pre_process_oid(Default0),
+    {exception,need(check_objectidentifier, 2),[Default]};
+do_gen({'CHOICE',Cs}, Default) ->
+    {Tag,Value} = Default,
+    [Type] = [Type || #'ComponentType'{name=T,typespec=Type} <- Cs,
+		      T =:= Tag],
+    case do_gen(Type#type.def, Value) of
+	{literal,Lit} ->
+	    {literal,{Tag,Lit}};
+	{exception,Func0,Args} ->
+	    Key = {Tag,Func0,Args},
+	    Gen = fun(Fd, Name) ->
+			  S = gen_choice(Name, Tag, Func0, Args),
+			  ok = file:write(Fd, S)
+		  end,
+	    Func = asn1ct_func:call_gen("is_default_choice", Key, Gen),
+	    {exception,atom_to_list(Func),[]}
+    end;
+do_gen(#'SEQUENCE'{components=Cs}, Default) ->
+    do_seq_set(Cs, Default);
+do_gen({'SEQUENCE OF',Type}, Default) ->
+    do_sof(Type, Default);
+do_gen(#'SET'{components=Cs}, Default) ->
+    do_seq_set(Cs, Default);
+do_gen({'SET OF',Type}, Default) ->
+    do_sof(Type, Default);
+do_gen(Type, Default) ->
+    case asn1ct_gen:unify_if_string(Type) of
+	restrictedstring ->
+	    {exception,need(check_restrictedstring, 2),[Default]};
+	_ ->
+	    %% Open type. Do our best.
+	    {literal,Default}
+    end.
+
+do_named_bitstring(NBL, Default0) when is_list(Default0) ->
+    Default = lists:sort(Default0),
+    Bs = asn1ct_gen:named_bitstring_value(Default, NBL),
+    Func = case asn1ct:use_legacy_types() of
+	       false -> check_named_bitstring;
+	       true -> check_legacy_named_bitstring
+	   end,
+    {exception,need(Func, 4),[Default,Bs,bit_size(Bs)]};
+do_named_bitstring(_, Default) when is_bitstring(Default) ->
+    Func = case asn1ct:use_legacy_types() of
+	       false -> check_named_bitstring;
+	       true -> check_legacy_named_bitstring
+	   end,
+    {exception,need(Func, 3),[Default,bit_size(Default)]}.
+
+do_seq_set(Cs0, Default) ->
+    Tag = element(1, Default),
+    Cs1 = [T || #'ComponentType'{typespec=T} <- Cs0],
+    Cs = components(Cs1, tl(tuple_to_list(Default))),
+    case are_all_literals(Cs) of
+	true ->
+	    Literal = list_to_tuple([Tag|[L || {literal,L} <- Cs]]),
+	    {literal,Literal};
+	false ->
+	    Key = {Cs,Default},
+	    Gen = fun(Fd, Name) ->
+			  S = gen_components(Name, Tag, Cs),
+			  ok = file:write(Fd, S)
+		  end,
+	    Func = asn1ct_func:call_gen("is_default_cs_", Key, Gen),
+	    {exception,atom_to_list(Func),[]}
+    end.
+
+do_sof(Type, Default0) ->
+    Default = lists:sort(Default0),
+    Cs0 = lists:duplicate(length(Default), Type),
+    Cs = components(Cs0, Default),
+    case are_all_literals(Cs) of
+	true ->
+	    Literal = [Lit || {literal,Lit} <- Cs],
+	    {exception,need(check_literal_sof, 2),[Literal]};
+	false ->
+	    Key = Cs,
+	    Gen = fun(Fd, Name) ->
+			  S = gen_sof(Name, Cs),
+			  ok = file:write(Fd, S)
+		  end,
+	    Func = asn1ct_func:call_gen("is_default_sof", Key, Gen),
+	    {exception,atom_to_list(Func),[]}
+    end.
+
+are_all_literals([{literal,_}|T]) ->
+    are_all_literals(T);
+are_all_literals([_|_]) ->
+    false;
+are_all_literals([]) -> true.
+
+gen_components(Name, Tag, Cs) ->
+    [atom_to_list(Name),"(Value) ->\n",
+     "case Value of\n",
+     "{",term2str(Tag)|gen_cs_1(Cs, 1, [])].
+
+gen_cs_1([{literal,Lit}|T], I, Acc) ->
+    [",\n",term2str(Lit)|gen_cs_1(T, I, Acc)];
+gen_cs_1([H|T], I, Acc) ->
+    Var = "E"++integer_to_list(I),
+    [",\n",Var|gen_cs_1(T, I+1, [{Var,H}|Acc])];
+gen_cs_1([], _, Acc) ->
+    ["} ->\n"|gen_cs_2(Acc, "")].
+
+gen_cs_2([{Var,{exception,Func,Args}}|T], Sep) ->
+    [Sep,Func,"(",Var,arg2str(Args),")"|gen_cs_2(T, ",\n")];
+gen_cs_2([], _) ->
+    [";\n",
+     "_ ->\n"
+     "throw(false)\n"
+     "end.\n"].
+
+gen_sof(Name, Cs) ->
+    [atom_to_list(Name),"(Value) ->\n",
+     "case length(Value) of\n",
+     integer_to_list(length(Cs))," -> ok;\n"
+     "_ -> throw(false)\n"
+     "end,\n"
+     "T0 = lists:sort(Value)"|gen_sof_1(Cs, 1)].
+
+gen_sof_1([{exception,Func,Args}|Cs], I) ->
+    NumStr = integer_to_list(I),
+    H = "H" ++ NumStr,
+    T = "T" ++ NumStr,
+    Prev = "T" ++ integer_to_list(I-1),
+    [",\n",
+     "[",H,case Cs of
+	       [] -> [];
+	       [_|_] -> ["|",T]
+	   end,"] = ",Prev,",\n",
+     Func,"(",H,arg2str(Args),")"|gen_sof_1(Cs, I+1)];
+gen_sof_1([], _) ->
+    ".\n".
+
+components([#type{def=Def}|Ts], [V|Vs]) ->
+    [do_gen(Def, V)|components(Ts, Vs)];
+components([], []) -> [].
+
+gen_choice(Name, Tag, Func, Args) ->
+    NameStr = atom_to_list(Name),
+    [NameStr,"({",term2str(Tag),",Value}) ->\n"
+     " ",Func,"(Value",arg2str(Args),");\n",
+     NameStr,"(_) ->\n"
+     " throw(false).\n"].
+
+pre_process_oid(Oid) ->
+    Reserved = reserved_oid(),
+    pre_process_oid(tuple_to_list(Oid), Reserved, []).
+
+pre_process_oid([H|T]=Tail, Res0, Acc) ->
+    case lists:keyfind(H, 2, Res0) of
+	false ->
+	    {lists:reverse(Acc),Tail};
+	{Names0,H,Res} ->
+	    Names = case is_list(Names0) of
+			false -> [Names0];
+			true -> Names0
+		    end,
+	    Keys = [H|Names],
+	    pre_process_oid(T, Res, [Keys|Acc])
+    end.
+
+reserved_oid() ->
+    [{['itu-t',ccitt],0,
+      [{recommendation,0,[]},
+       {question,1,[]},
+       {administration,2,[]},
+       {'network-operator',3,[]},
+       {'identified-organization',4,[]}]},
+     {iso,1,[{standard,0,[]},
+	     {'member-body',2,[]},
+	     {'identified-organization',3,[]}]},
+     {['joint-iso-itu-t','joint-iso-ccitt'],2,[]}].
+
+arg2str(Args) ->
+    [", "++term2str(Arg) || Arg <- Args].
+
+term2str(T) ->
+    io_lib:format("~w", [T]).
+
+need(F, A) ->
+    asn1ct_func:need({check,F,A}),
+    atom_to_list(F).
diff --git a/lib/asn1/src/asn1ct_gen_per.erl b/lib/asn1/src/asn1ct_gen_per.erl
index 69d9d51bf1..aa7223904e 100644
--- a/lib/asn1/src/asn1ct_gen_per.erl
+++ b/lib/asn1/src/asn1ct_gen_per.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -26,12 +27,13 @@
 %-compile(export_all).
 
 -export([gen_dec_imm/2]).
--export([gen_dec_prim/3,gen_encode_prim/3]).
+-export([gen_dec_prim/3,gen_encode_prim_imm/3]).
 -export([gen_obj_code/3,gen_objectset_code/2]).
 -export([gen_decode/2, gen_decode/3]).
 -export([gen_encode/2, gen_encode/3]).
 -export([gen_dec_external/2]).
 -export([extaddgroup2sequence/1]).
+-export([dialyzer_suppressions/1]).
 
 -import(asn1ct_gen, [emit/1,demit/1]).
 -import(asn1ct_func, [call/3]).
@@ -40,6 +42,15 @@
 %% Generate ENCODING ******************************
 %%****************************************x
 
+dialyzer_suppressions(Erules) ->
+    case asn1ct_func:is_used({Erules,complete,1}) of
+	false ->
+	    ok;
+	true ->
+	    emit(["    _ = complete(Arg),",nl])
+    end,
+    emit(["    ok.",nl]).
+
 
 gen_encode(Erules,Type) when is_record(Type,typedef) ->
     gen_encode_user(Erules,Type).
@@ -99,835 +110,122 @@ gen_encode_user(Erules,D) when is_record(D,typedef) ->
 
 
 gen_encode_prim(Erules, D) ->
-    Value = asn1ct_gen:mk_var(asn1ct_name:curr(val)),
+    Value = {var,atom_to_list(asn1ct_gen:mk_var(asn1ct_name:curr(val)))},
     gen_encode_prim(Erules, D, Value).
 
-gen_encode_prim(Erules, #type{def={'ENUMERATED',{N1,N2}}}, Value) ->
-    NewList = [{0,X} || {X,_} <- N1] ++ ['EXT_MARK'] ++
-	[{1,X} || {X,_} <- N2],
-    NewC = {0,length(N1)-1},
-    emit(["case ",Value," of",nl]),
-    emit_enc_enumerated_cases(Erules, NewC, NewList, 0);
-gen_encode_prim(Erules, #type{def={'ENUMERATED',NNL}}, Value) ->
-    NewList = [X || {X,_} <- NNL],
-    NewC = {0,length(NewList)-1},
-    emit(["case ",Value," of",nl]),
-    emit_enc_enumerated_cases(Erules, NewC, NewList, 0);
-gen_encode_prim(per=Erules, D, Value) ->
-    asn1ct_gen_per_rt2ct:gen_encode_prim(Erules, D, Value);
 gen_encode_prim(Erules, #type{}=D, Value) ->
-    Constraint = D#type.constraint,
-    SizeConstr = asn1ct_imm:effective_constraint(bitstring, Constraint),
-    Pa = case lists:keyfind('PermittedAlphabet', 1, Constraint) of
-	     false -> no;
-	     {_,Pa0} -> Pa0
-	 end,
-    case D#type.def of
+    Aligned = case Erules of
+		  uper -> false;
+		  per -> true
+	      end,
+    Imm = gen_encode_prim_imm(Value, D, Aligned),
+    asn1ct_imm:enc_cg(Imm, Aligned).
+
+gen_encode_prim_imm(Val, #type{def=Type0,constraint=Constraint}, Aligned) ->
+    case simplify_type(Type0) of
+	k_m_string ->
+	    Type = case Type0 of
+		       'GeneralizedTime' -> 'VisibleString';
+		       'UTCTime' -> 'VisibleString';
+		       _ -> Type0
+		   end,
+	    asn1ct_imm:per_enc_k_m_string(Val, Type, Constraint, Aligned);
+	restricted_string ->
+	    ToBinary = {erlang,iolist_to_binary},
+	    asn1ct_imm:per_enc_restricted_string(Val, ToBinary, Aligned);
+	{'ENUMERATED',NNL} ->
+	    asn1ct_imm:per_enc_enumerated(Val, NNL, Aligned);
 	'INTEGER' ->
-	    Args = [{asis,asn1ct_imm:effective_constraint(integer,Constraint)},
-		    Value],
-	    call(Erules, encode_integer, Args);
-	{'INTEGER',NamedNumberList} ->
-	    Args = [{asis,asn1ct_imm:effective_constraint(integer,Constraint)},
-		    Value,{asis,NamedNumberList}],
-	    call(Erules, encode_integer, Args);
+	    asn1ct_imm:per_enc_integer(Val, Constraint, Aligned);
+	{'INTEGER',NNL} ->
+	    asn1ct_imm:per_enc_integer(Val, NNL, Constraint, Aligned);
 	'REAL' ->
-	    emit_enc_real(Erules, Value);
-
-	{'BIT STRING',NamedNumberList} ->
-	    call(Erules, encode_bit_string,
-		 [{asis,SizeConstr},Value,
-		  {asis,NamedNumberList}]);
+	    ToBinary = {real_common,encode_real},
+	    asn1ct_imm:per_enc_restricted_string(Val, ToBinary, Aligned);
+	{'BIT STRING',NNL} ->
+	    case asn1ct:use_legacy_types() of
+		false ->
+		    asn1ct_imm:per_enc_bit_string(Val, NNL,
+						  Constraint, Aligned);
+		true ->
+		    asn1ct_imm:per_enc_legacy_bit_string(Val, NNL,
+							 Constraint, Aligned)
+	    end;
 	'NULL' ->
-	    emit("[]");
+	    asn1ct_imm:per_enc_null(Val, Aligned);
 	'OBJECT IDENTIFIER' ->
-	    call(Erules, encode_object_identifier, [Value]);
+	    ToBinary = {per_common,encode_oid},
+	    asn1ct_imm:per_enc_restricted_string(Val, ToBinary, Aligned);
 	'RELATIVE-OID' ->
-	    call(Erules, encode_relative_oid, [Value]);
-	'ObjectDescriptor' ->
-	    call(Erules, encode_ObjectDescriptor,
-		 [{asis,Constraint},Value]);
+	    ToBinary = {per_common,encode_relative_oid},
+	    asn1ct_imm:per_enc_restricted_string(Val, ToBinary, Aligned);
 	'BOOLEAN' ->
-	    call(Erules, encode_boolean, [Value]);
+	    asn1ct_imm:per_enc_boolean(Val, Aligned);
 	'OCTET STRING' ->
-	    case SizeConstr of
-		0 ->
-		    emit("[]");
-		no ->
-		    call(Erules, encode_octet_string, [Value]);
-		C ->
-		    call(Erules, encode_octet_string, [{asis,C},Value])
+	    case asn1ct:use_legacy_types() of
+		false ->
+		    asn1ct_imm:per_enc_octet_string(Val, Constraint, Aligned);
+		true ->
+		    asn1ct_imm:per_enc_legacy_octet_string(Val, Constraint,
+							   Aligned)
 	    end;
-	'NumericString' ->
-	    call(Erules, encode_NumericString, [{asis,SizeConstr},
-						{asis,Pa},Value]);
-	TString when TString == 'TeletexString';
-		     TString == 'T61String' ->
-	    call(Erules, encode_TeletexString, [{asis,Constraint},Value]);
-	'VideotexString' ->
-	    call(Erules, encode_VideotexString, [{asis,Constraint},Value]);
-	'UTCTime' ->
-	    call(Erules, encode_VisibleString, [{asis,SizeConstr},
-						{asis,Pa},Value]);
-	'GeneralizedTime' ->
-	    call(Erules, encode_VisibleString, [{asis,SizeConstr},
-						{asis,Pa},Value]);
-	'GraphicString' ->
-	    call(Erules, encode_GraphicString, [{asis,Constraint},Value]);
-	'VisibleString' ->
-	    call(Erules, encode_VisibleString, [{asis,SizeConstr},
-						{asis,Pa},Value]);
-	'GeneralString' ->
-	    call(Erules, encode_GeneralString, [{asis,Constraint},Value]);
-	'PrintableString' ->
-	    call(Erules, encode_PrintableString, [{asis,SizeConstr},
-						  {asis,Pa},Value]);
-	'IA5String' ->
-	    call(Erules, encode_IA5String, [{asis,SizeConstr},
-					    {asis,Pa},Value]);
-	'BMPString' ->
-	    call(Erules, encode_BMPString, [{asis,SizeConstr},
-					    {asis,Pa},Value]);
-	'UniversalString' ->
-	    call(Erules, encode_UniversalString, [{asis,SizeConstr},
-						  {asis,Pa},Value]);
-	'UTF8String' ->
-	    call(Erules, encode_UTF8String, [Value]);
 	'ASN1_OPEN_TYPE' ->
-	    NewValue = case Constraint of
-			   [#'Externaltypereference'{type=Tname}] ->
-			       asn1ct_func:need({Erules,complete,1}),
-			       io_lib:format(
-				 "complete(enc_~s(~s))",[Tname,Value]);
-			   [#type{def=#'Externaltypereference'{type=Tname}}] ->
-			       asn1ct_func:need({Erules,complete,1}),
-			       io_lib:format(
-				 "complete(enc_~s(~s))",
-				 [Tname,Value]);
-			   _ ->
-			       io_lib:format("iolist_to_binary(~s)",
-					     [Value])
-		     end,
-	    call(Erules, encode_open_type, [NewValue])
-    end.
-
-emit_enc_real(Erules, Real) ->
-    asn1ct_name:new(tmpval),
-    asn1ct_name:new(tmplen),
-    emit(["begin",nl,
-	  "{",{curr,tmpval},com,{curr,tmplen},"} = ",
-	  {call,real_common,encode_real,[Real]},com,nl,
-	  "[",{call,Erules,encode_length,[{curr,tmplen}]},",",
-	  {curr,tmpval},"]",nl,
-	  "end"]).
-
-emit_enc_enumerated_cases(Erules, C, ['EXT_MARK'|T], _Count) ->
-    %% Reset enumeration counter.
-    emit_enc_enumerated_cases(Erules, C, T, 0);
-emit_enc_enumerated_cases(Erules, C, [H|T], Count) ->
-    emit_enc_enumerated_case(Erules, C, H, Count),
-    emit([";",nl]),
-    emit_enc_enumerated_cases(Erules, C, T, Count+1);
-emit_enc_enumerated_cases(_Erules, _, [], _Count) ->
-    emit(["EnumVal -> "
-	  "exit({error,{asn1,{enumerated_not_in_range, EnumVal}}})",nl,
-	  "end"]).
-    
-emit_enc_enumerated_case(Erules, C, {0,EnumName}, Count) ->
-    %% ENUMERATED with extensionmark; the value lies within then extension root
-    Enc = enc_ext_and_val(Erules, 0, encode_constrained_number, [C,Count]),
-    emit(["'",EnumName,"' -> ",{asis,Enc}]);
-emit_enc_enumerated_case(Erules, _C, {1,EnumName}, Count) ->
-    %% ENUMERATED with extensionmark; the value is higher than extension root
-    Enc = enc_ext_and_val(Erules, 1, encode_small_number, [Count]),
-    emit(["'",EnumName,"' -> ",{asis,Enc}]);
-emit_enc_enumerated_case(Erules, C, EnumName, Count) ->
-    %% ENUMERATED without extension
-    EvalMod = eval_module(Erules),
-    emit(["'",EnumName,"' -> ",
-	  {asis,EvalMod:encode_constrained_number(C, Count)}]).
-
-enc_ext_and_val(per, E, F, Args) ->
-    [E|apply(asn1ct_eval_per, F, Args)];
-enc_ext_and_val(uper, E, F, Args) ->
-    Bs = list_to_bitstring([apply(asn1ct_eval_uper, F, Args)]),
-    <<E:1,Bs/bitstring>>.
-
-
-%% Object code generating for encoding and decoding
-%% ------------------------------------------------
-
-gen_obj_code(Erules,_Module,Obj) when is_record(Obj,typedef) ->
-    ObjName = Obj#typedef.name,
-    Def = Obj#typedef.typespec,
-    #'Externaltypereference'{module=Mod,type=ClassName} = 
-	Def#'Object'.classname,
-    Class = asn1_db:dbget(Mod,ClassName),
-    {object,_,Fields} = Def#'Object'.def,
-    emit({nl,nl,nl,"%%================================"}),
-    emit({nl,"%%  ",ObjName}),
-    emit({nl,"%%================================",nl}),
-    EncConstructed =
-	gen_encode_objectfields(Erules, ClassName,get_class_fields(Class),
-				ObjName,Fields,[]),
-    emit(nl),
-    gen_encode_constr_type(Erules,EncConstructed),
-    emit(nl),
-    DecConstructed =
-	gen_decode_objectfields(Erules, ClassName, get_class_fields(Class),
-				ObjName, Fields, []),
-    emit(nl),
-    gen_decode_constr_type(Erules,DecConstructed),
-    emit(nl).
-
-
-gen_encode_objectfields(Erule, ClassName,
-			[{typefield,Name,OptOrMand}|Rest],
-			ObjName, ObjectFields, ConstrAcc) ->
-    EmitFuncClause = 
-	fun(V) ->
-		emit(["'enc_",ObjName,"'(",{asis,Name},
-		      ",",V,",_RestPrimFieldName) ->",nl])
-	end,
-%     emit(["'enc_",ObjName,"'(",{asis,Name},
-% 	  ", Val, _RestPrimFieldName) ->",nl]),
-    MaybeConstr =
-	case {get_object_field(Name,ObjectFields),OptOrMand} of
-	    {false,'MANDATORY'} -> %% this case is illegal
-		exit({error,{asn1,{"missing mandatory field in object",
-				   ObjName}}});
-	    {false,'OPTIONAL'} ->
-		EmitFuncClause("Val"),
-		case Erule of
-		    uper ->
-			emit("   Val");
-		    per ->
-			emit(["   if",nl,
-			      "     is_list(Val) ->",nl,
-			      "       NewVal = list_to_binary(Val),",nl,
-			      "       [20,byte_size(NewVal),NewVal];",nl,
-			      "     is_binary(Val) ->",nl,
-			      "       [20,byte_size(Val),Val]",nl,
-			      "   end"])
-		end,
-		[];
-	    {false,{'DEFAULT',DefaultType}} ->
-		EmitFuncClause("Val"),
-		gen_encode_default_call(Erule, ClassName, Name, DefaultType);
-	    {{Name,TypeSpec},_} ->
-		%% A specified field owerwrites any 'DEFAULT' or
-		%% 'OPTIONAL' field in the class
-		EmitFuncClause("Val"),
-		gen_encode_field_call(Erule, ObjName, Name, TypeSpec)
-	end,
-    case more_genfields(Rest) of
-	true ->
-	    emit([";",nl]);
-	false ->
-	    emit([".",nl])
-    end,
-    gen_encode_objectfields(Erule,ClassName,Rest,ObjName,ObjectFields,
-			    MaybeConstr++ConstrAcc);
-gen_encode_objectfields(Erule,ClassName,[{objectfield,Name,_,_,OptOrMand}|Rest],
-			ObjName,ObjectFields,ConstrAcc) ->
-    CurrentMod = get(currmod),
-    EmitFuncClause =
-	fun(Attrs) ->
-		emit(["'enc_",ObjName,"'(",{asis,Name},
-		      ",",Attrs,") ->",nl])
-	end,
-%     emit(["'enc_",ObjName,"'(",{asis,Name},
-% 	  ", Val,[H|T]) ->",nl]),
-    case {get_object_field(Name,ObjectFields),OptOrMand} of
-	{false,'MANDATORY'} ->
-	    exit({error,{asn1,{"missing mandatory field in object",
-			       ObjName}}});
-	{false,'OPTIONAL'} ->
-	    EmitFuncClause("_,_"),
-	    emit(["  exit({error,{'use of missing field in object', ",{asis,Name},
-		  "}})"]);
-	{false,{'DEFAULT',_DefaultObject}} ->
-	    exit({error,{asn1,{"not implemented yet",Name}}});
-	{{Name,#'Externalvaluereference'{module=CurrentMod,
-					 value=TypeName}},_} ->
-	    EmitFuncClause(" Val, [H|T]"),
-	    emit({indent(3),"'enc_",TypeName,"'(H, Val, T)"});
-	{{Name,#'Externalvaluereference'{module=M,value=TypeName}},_} ->
-	    EmitFuncClause(" Val, [H|T]"),
-	    emit({indent(3),"'",M,"':'enc_",TypeName,"'(H, Val, T)"});
-	{{Name,TypeSpec},_} ->
-	    EmitFuncClause("Val,[H|T]"),
-	    case TypeSpec#typedef.name of
-		{ExtMod,TypeName} ->
-		    emit({indent(3),"'",ExtMod,"':'enc_",TypeName,
-			  "'(H, Val, T)"});
-		TypeName ->
-		    emit({indent(3),"'enc_",TypeName,"'(H, Val, T)"})
+	    case Constraint of
+		[#'Externaltypereference'{type=Tname}] ->
+		    EncFunc = enc_func(Tname),
+		    Imm = [{apply,{local,EncFunc,[]},[Val]}],
+		    asn1ct_imm:per_enc_open_type(Imm, Aligned);
+		[] ->
+		    Imm = [{call,erlang,iolist_to_binary,[Val]}],
+		    asn1ct_imm:per_enc_open_type(Imm, Aligned)
 	    end
-    end,
-    case more_genfields(Rest) of
-	true ->
-	    emit([";",nl]);
-	false ->
-	    emit([".",nl])
-    end,
-    gen_encode_objectfields(Erule,ClassName,Rest,ObjName,ObjectFields,ConstrAcc);
-gen_encode_objectfields(Erule,ClassName,[_C|Cs],O,OF,Acc) ->
-    gen_encode_objectfields(Erule,ClassName,Cs,O,OF,Acc);
-gen_encode_objectfields(_, _,[],_,_,Acc) ->
-    Acc.
-
-
-gen_encode_constr_type(Erules,[TypeDef|Rest]) when is_record(TypeDef,typedef) ->
-    case is_already_generated(enc,TypeDef#typedef.name) of
-	true -> ok;
-	_ ->
-%%	    FuncName = list_to_atom(lists:concat(["enc_",TypeDef#typedef.name])),
-	    FuncName = asn1ct_gen:list2rname(TypeDef#typedef.name ++ [enc]),
-	    emit(["'",FuncName,"'(Val) ->",nl]),
-	    Def = TypeDef#typedef.typespec,
-	    InnerType = asn1ct_gen:get_inner(Def#type.def),
-	    asn1ct_gen:gen_encode_constructed(Erules,TypeDef#typedef.name,
-					      InnerType,Def),
-	    gen_encode_constr_type(Erules,Rest)
-    end;
-gen_encode_constr_type(_,[]) ->
-    ok.
-
-gen_encode_field_call(_Erules, _ObjName, _FieldName,
-		      #'Externaltypereference'{module=M,type=T}) ->
-    CurrentMod = get(currmod),
-    if
-	M == CurrentMod ->
-	    emit({"   'enc_",T,"'(Val)"}),
-	    [];
-	true ->
-	    emit({"   '",M,"':'enc_",T,"'(Val)"}),
-	    []
-    end;
-gen_encode_field_call(Erules, ObjName, FieldName, Type) ->
-    Def = Type#typedef.typespec,
-    case Type#typedef.name of
-	{primitive,bif} -> 
-	    gen_encode_prim(Erules, Def, "Val"),
-	    [];
-	{constructed,bif} ->
-	    emit({"   'enc_",ObjName,'_',FieldName,
-		  "'(Val)"}),
-%%	    [Type#typedef{name=list_to_atom(lists:concat([ObjName,'_',FieldName]))}];
-	    [Type#typedef{name=[FieldName,ObjName]}];
-	{ExtMod,TypeName} ->
-	    emit({"   '",ExtMod,"':'enc_",TypeName,
-		  "'(Val)"}),
-	    [];
-	TypeName ->
-	    emit({"   'enc_",TypeName,"'(Val)"}),
-	    []
     end.
 
-gen_encode_default_call(Erules, ClassName, FieldName, Type) ->
-    CurrentMod = get(currmod),
-    InnerType = asn1ct_gen:get_inner(Type#type.def),
-    case asn1ct_gen:type(InnerType) of
-    	{constructed,bif} ->
-%%	    asn1ct_gen:gen_encode_constructed(Erules,Typename,InnerType,Type);
-	    emit(["   'enc_",ClassName,'_',FieldName,"'(Val)"]),
-%%	    [#typedef{name=list_to_atom(lists:concat([ClassName,'_',FieldName])),
-	    [#typedef{name=[FieldName,ClassName],
-		      typespec=Type}];
-	{primitive,bif} ->
-	    gen_encode_prim(Erules, Type, "Val"),
-	    [];
-	#'Externaltypereference'{module=CurrentMod,type=Etype} ->
-	    emit(["   'enc_",Etype,"'(Val)",nl]),
-	    [];
-	#'Externaltypereference'{module=Emod,type=Etype} ->
-	    emit(["   '",Emod,"':'enc_",Etype,"'(Val)",nl]),
-	    []
-    end.
-    
-
-gen_decode_objectfields(Erules, ClassName,
-			[{typefield,Name,OptOrMand}|Rest],
-			ObjName, ObjectFields, ConstrAcc) ->
-    EmitFuncClause = 
-	fun(Bytes) ->
-		emit(["'dec_",ObjName,"'(",{asis,Name},",",Bytes,
-		      ",_,_RestPrimFieldName) ->",nl])
-	end,
-    MaybeConstr=
-	case {get_object_field(Name,ObjectFields),OptOrMand} of
-	    {false,'MANDATORY'} -> %% this case is illegal
-		exit({error,{asn1,{"missing mandatory field in object",
-				   ObjName}}});
-	    {false,'OPTIONAL'} ->
-		EmitFuncClause("Bytes"),
-		emit(["   {Bytes,[]}"]),
-		[];
-	    {false,{'DEFAULT',DefaultType}} ->
-		EmitFuncClause("Bytes"),
-		gen_decode_default_call(Erules, ClassName, Name, "Bytes",
-					DefaultType);
-	    {{Name,TypeSpec},_} ->
-		%% A specified field owerwrites any 'DEFAULT' or
-		%% 'OPTIONAL' field in the class
-		EmitFuncClause("Bytes"),
-		gen_decode_field_call(Erules, ObjName, Name, "Bytes", TypeSpec)
-	end,
-    case more_genfields(Rest) of
-	true ->
-	    emit([";",nl]);
-	false ->
-	    emit([".",nl])
-    end,
-    gen_decode_objectfields(Erules, ClassName, Rest, ObjName,
-			    ObjectFields, MaybeConstr++ConstrAcc);
-gen_decode_objectfields(Erules, ClassName,
-			[{objectfield,Name,_,_,OptOrMand}|Rest],
-			ObjName, ObjectFields, ConstrAcc) ->
-    CurrentMod = get(currmod),
-    EmitFuncClause =
-	fun(Attrs) ->
-		emit(["'dec_",ObjName,"'(",{asis,Name},
-		      ",",Attrs,") ->",nl])
-	end,
-%     emit(["'dec_",ObjName,"'(",{asis,Name},
-% 	  ", Bytes,_,[H|T]) ->",nl]),
-    case {get_object_field(Name,ObjectFields),OptOrMand} of
-	{false,'MANDATORY'} ->
-	    exit({error,{asn1,{"missing mandatory field in object",
-			       ObjName}}});
-	{false,'OPTIONAL'} ->
-	    EmitFuncClause("_,_,_"),
-	    emit(["  exit({error,{'illegal use of missing field in object', ",{asis,Name},
-		  "}})"]);
-	{false,{'DEFAULT',_DefaultObject}} ->
-	    exit({error,{asn1,{"not implemented yet",Name}}});
-	{{Name,#'Externalvaluereference'{module=CurrentMod,
-					 value=TypeName}},_} ->
-	    EmitFuncClause("Bytes,_,[H|T]"),
-	    emit({indent(3),"'dec_",TypeName,"'(H, Bytes, telltype, T)"});
-	{{Name,#'Externalvaluereference'{module=M,value=TypeName}},_} ->
-	    EmitFuncClause("Bytes,_,[H|T]"),
-	    emit({indent(3),"'",M,"':'dec_",TypeName,
-		  "'(H, Bytes, telltype, T)"});
-	{{Name,TypeSpec},_} ->
-	    EmitFuncClause("Bytes,_,[H|T]"),
-	    case TypeSpec#typedef.name of
-		{ExtMod,TypeName} ->
-		    emit({indent(3),"'",ExtMod,"':'dec_",TypeName,
-			  "'(H, Bytes, telltype, T)"});
-		TypeName ->
-		    emit({indent(3),"'dec_",TypeName,"'(H, Bytes, telltype, T)"})
-	    end
-    end,
-    case more_genfields(Rest) of
-	true ->
-	    emit([";",nl]);
-	false ->
-	    emit([".",nl])
-    end,
-    gen_decode_objectfields(Erules, ClassName, Rest, ObjName,
-			    ObjectFields, ConstrAcc);
-gen_decode_objectfields(Erules, CN, [_C|Cs], O, OF, CAcc) ->
-    gen_decode_objectfields(Erules, CN, Cs, O, OF, CAcc);
-gen_decode_objectfields(_, _, [], _, _, CAcc) ->
-    CAcc.
-
-
-
-gen_decode_field_call(_Erules, _ObjName, _FieldName, Bytes,
-		      #'Externaltypereference'{}=Etype) ->
-    emit("   "),
-    gen_dec_external(Etype, Bytes),
-    [];
-gen_decode_field_call(Erules, ObjName, FieldName, Bytes, Type) ->
-    Def = Type#typedef.typespec,
-    case Type#typedef.name of
-	{primitive,bif} -> 
-	    gen_dec_prim(Erules, Def, Bytes),
-	    [];
-	{constructed,bif} ->
-	    emit({"   'dec_",ObjName,'_',FieldName,
-		  "'(",Bytes,",telltype)"}),
-%%	    [Type#typedef{name=list_to_atom(lists:concat([ObjName,'_',FieldName]))}];
-	    [Type#typedef{name=[FieldName,ObjName]}];
-	{ExtMod,TypeName} ->
-	    emit({"   '",ExtMod,"':'dec_",TypeName,
-		  "'(",Bytes,", telltype)"}),
-	    [];
-	TypeName ->
-	    emit({"   'dec_",TypeName,"'(",Bytes,", telltype)"}),
-	    []
-    end.
-
-gen_decode_default_call(Erules, ClassName, FieldName, Bytes, Type) ->
-    InnerType = asn1ct_gen:get_inner(Type#type.def),
-    case asn1ct_gen:type(InnerType) of
-    	{constructed,bif} ->
-	    emit(["   'dec_",ClassName,'_',FieldName,"'(",Bytes,", telltype)"]),
-%%	    [#typedef{name=list_to_atom(lists:concat([ClassName,'_',FieldName])),
-	    [#typedef{name=[FieldName,ClassName],
-		      typespec=Type}];
-	{primitive,bif} ->
-	    gen_dec_prim(Erules, Type, Bytes),
-	    [];
-	#'Externaltypereference'{}=Etype ->
-	    asn1ct_gen_per:gen_dec_external(Etype, Bytes),
-	    []
+dec_func(Tname) ->
+    list_to_atom(lists:concat(["dec_",Tname])).
+
+enc_func(Tname) ->
+    list_to_atom(lists:concat(["enc_",Tname])).
+
+simplify_type(Type) ->
+    case Type of
+	'BMPString'       -> k_m_string;
+	'IA5String'       -> k_m_string;
+	'NumericString'   -> k_m_string;
+	'PrintableString' -> k_m_string;
+	'VisibleString'   -> k_m_string;
+	'UniversalString' -> k_m_string;
+	'GeneralizedTime' -> k_m_string;
+	'UTCTime'         -> k_m_string;
+	'TeletexString'   -> restricted_string;
+	'T61String'       -> restricted_string;
+	'VideotexString'  -> restricted_string;
+	'GraphicString'   -> restricted_string;
+	'GeneralString'   -> restricted_string;
+	'UTF8String'      -> restricted_string;
+	'ObjectDescriptor' -> restricted_string;
+	Other             -> Other
     end.
 
+%% Object code generating for encoding and decoding
+%% ------------------------------------------------
 
-gen_decode_constr_type(Erules,[TypeDef|Rest]) when is_record(TypeDef,typedef) ->
-    case is_already_generated(dec,TypeDef#typedef.name) of
-	true -> ok;
-	_ ->
-	    gen_decode(Erules,TypeDef#typedef{name=asn1ct_gen:list2rname(TypeDef#typedef.name)})
-    end,
-    gen_decode_constr_type(Erules,Rest);
-gen_decode_constr_type(_,[]) ->
+gen_obj_code(_Erules, _Module, #typedef{}) ->
     ok.
 
-
-more_genfields([]) ->
-    false;
-more_genfields([Field|Fields]) ->
-    case element(1,Field) of
-	typefield ->
-	    true;
-	objectfield ->
-	    true;
-	_ ->
-	    more_genfields(Fields)
-    end.
-
 %% Object Set code generating for encoding and decoding
 %% ----------------------------------------------------
-gen_objectset_code(Erules,ObjSet) ->
-    ObjSetName = ObjSet#typedef.name,
-    Def = ObjSet#typedef.typespec,
-%%    {ClassName,ClassDef} = Def#'ObjectSet'.class,
-    #'Externaltypereference'{module=ClassModule,
-			     type=ClassName} = Def#'ObjectSet'.class,
-    ClassDef = asn1_db:dbget(ClassModule,ClassName),
-    UniqueFName = Def#'ObjectSet'.uniquefname,
-    Set = Def#'ObjectSet'.set,
-    emit({nl,nl,nl,"%%================================"}),
-    emit({nl,"%%  ",ObjSetName}),
-    emit({nl,"%%================================",nl}),
-    case ClassName of
-	{_Module,ExtClassName} ->
-	    gen_objset_code(Erules,ObjSetName,UniqueFName,Set,
-			    ExtClassName,ClassDef);
-	_ ->
-	    gen_objset_code(Erules,ObjSetName,UniqueFName,Set,
-			    ClassName,ClassDef)
-    end,
-    emit(nl).
-
-gen_objset_code(Erules,ObjSetName,UniqueFName,Set,ClassName,ClassDef)->
-    ClassFields = (ClassDef#classdef.typespec)#objectclass.fields,
-    InternalFuncs=
-	gen_objset_enc(Erules,ObjSetName,UniqueFName,Set,ClassName,ClassFields,1,[]),
-    gen_objset_dec(Erules, ObjSetName,UniqueFName,Set,ClassName,ClassFields,1),
-    gen_internal_funcs(Erules,InternalFuncs).
-
-%% gen_objset_enc iterates over the objects of the object set
-gen_objset_enc(_,_,{unique,undefined},_,_,_,_,_) ->
-    %% There is no unique field in the class of this object set
-    %% don't bother about the constraint
-    [];
-gen_objset_enc(Erule, ObjSetName, UniqueName, [{ObjName,Val,Fields}|T],
-	       ClName, ClFields, NthObj, Acc)->
-    emit(["'getenc_",ObjSetName,"'(",{asis,UniqueName},",",{asis,Val},
-	  ") ->",nl]),
-    CurrMod = get(currmod),
-    {InternalFunc,NewNthObj}=
-	case ObjName of
-	    {no_mod,no_name} ->
-		gen_inlined_enc_funs(Erule, Fields, ClFields,
-				     ObjSetName, NthObj);
-	    {CurrMod,Name} ->
-		emit({"    fun 'enc_",Name,"'/3"}),
-		{[],0};
-	    {ModName,Name} ->
-		emit_ext_encfun(ModName,Name),
-		{[],0};
-	    _Other ->
-		emit({"    fun 'enc_",ObjName,"'/3"}),
-		{[],0}
-	end,
-    emit({";",nl}),
-    gen_objset_enc(Erule, ObjSetName, UniqueName, T, ClName, ClFields,
-		   NewNthObj, InternalFunc ++ Acc);
-gen_objset_enc(uper, ObjSetName, _UniqueName, ['EXTENSIONMARK'],
-	       _ClName, _ClFields, _NthObj, Acc) ->
-    emit({"'getenc_",ObjSetName,"'(_, _) ->",nl}),
-    emit({indent(3),"fun(_, Val, _) ->",nl}),
-    emit([indent(6),"Val",nl,
-	  indent(3),"end.",nl,nl]),
-    Acc;
-gen_objset_enc(per, ObjSetName, _UniqueName, ['EXTENSIONMARK'],
-	       _ClName, _ClFields, _NthObj, Acc) ->
-    emit(["'getenc_",ObjSetName,"'(_, _) ->",nl,
-	  indent(3),"fun(_, Val, _) ->",nl,
-	  indent(6),"BinVal = if",nl,
-	  indent(9),"is_list(Val) -> list_to_binary(Val);",nl,
-	  indent(9),"true -> Val",nl,
-	  indent(6),"end,",nl,
-	  indent(6),"Size = byte_size(BinVal),",nl,
-	  indent(6),"if",nl,
-	  indent(9),"Size < 256 ->",nl,
-	  indent(12),"[20,Size,BinVal];",nl,
-	  indent(9),"true ->",nl,
-	  indent(12),"[21,<<Size:16>>,Val]",nl,
-	  indent(6),"end",nl,
-	  indent(3),"end.",nl,nl]),
-    Acc;
-gen_objset_enc(_, ObjSetName, UniqueName, [], _, _, _, Acc) ->
-    emit_default_getenc(ObjSetName, UniqueName),
-    emit([".",nl,nl]),
-    Acc.
-
-emit_ext_encfun(ModuleName,Name) ->
-    emit([indent(4),"fun(T,V,O) -> '",ModuleName,"':'enc_",
-	  Name,"'(T,V,O) end"]).
-
-emit_default_getenc(ObjSetName,UniqueName) ->
-    emit(["'getenc_",ObjSetName,"'(",{asis,UniqueName},", ErrV) ->",nl]),
-    emit([indent(4),"fun(C,V,_) -> exit({'Type not compatible with table constraint',{component,C},{value,V},{unique_name_and_value,",{asis,UniqueName},",ErrV}}) end"]).
-
-
-%% gen_inlined_enc_funs for each object iterates over all fields of a
-%% class, and for each typefield it checks if the object has that
-%% field and emits the proper code.
-gen_inlined_enc_funs(Erule, Fields, [{typefield,_,_}|_]=T,
-		     ObjSetName, NthObj) ->
-    emit([indent(3),"fun(Type, Val, _) ->",nl,
-	  indent(6),"case Type of",nl]),
-    gen_inlined_enc_funs1(Erule, Fields, T, ObjSetName, [], NthObj, []);
-gen_inlined_enc_funs(Erule,Fields,[_H|Rest],ObjSetName,NthObj) ->
-    gen_inlined_enc_funs(Erule,Fields,Rest,ObjSetName,NthObj);
-gen_inlined_enc_funs(_,_,[],_,NthObj) ->
-    {[],NthObj}.
-
-gen_inlined_enc_funs1(Erule, Fields, [{typefield,Name,_}|Rest], ObjSetName,
-		      Sep0, NthObj, Acc0) ->
-    emit(Sep0),
-    Sep = [";",nl],
-    CurrentMod = get(currmod),
-    InternalDefFunName = asn1ct_gen:list2name([NthObj,Name,ObjSetName]),
-    {Acc,NAdd} =
-	case lists:keyfind(Name, 1, Fields) of
-	    {_,#type{}=Type} ->
-		{Ret,N} = emit_inner_of_fun(Erule, Type, InternalDefFunName),
-		{Ret++Acc0,N};
-	    {_,#typedef{}=Type} ->
-		emit([indent(9),{asis,Name}," ->",nl]),
-		{Ret,N} = emit_inner_of_fun(Erule, Type, InternalDefFunName),
-		{Ret++Acc0,N};
-	    {_,#'Externaltypereference'{module=CurrentMod,type=T}} ->
-		emit([indent(9),{asis,Name}," ->",nl,
-		      indent(12),"'enc_",T,"'(Val)"]),
-		{Acc0,0};
-	    {_,#'Externaltypereference'{module=M,type=T}} ->
-		emit([indent(9),{asis,Name}," ->",nl,
-		      indent(12),"'",M,"'",":'enc_",T,"'(Val)"]),
-		{Acc0,0};
-	    false when Erule =:= uper ->
-		emit([indent(9),{asis,Name}," ->",nl,
-		      indent(12),"Val",nl]),
-		{Acc0,0};
-	    false when Erule =:= per ->
-		emit([indent(9),{asis,Name}," ->",nl,
-		      indent(12),"Size = case Val of",nl,
-		      indent(15),"B when is_binary(B) -> size(B);",nl,
-		      indent(15),"_ -> length(Val)",nl,
-		      indent(12),"end,",nl,
-		      indent(12),"if",nl,
-		      indent(15),"Size < 256 -> [20,Size,Val];",nl,
-		      indent(15),"true -> [21,<<Size:16>>,Val]",nl,
-		      indent(12),"end"]),
-		{Acc0,0}
-	end,
-    gen_inlined_enc_funs1(Erule, Fields, Rest, ObjSetName, Sep,
-			  NthObj+NAdd, Acc);
-gen_inlined_enc_funs1(Erule, Fields, [_|T], ObjSetName, Sep, NthObj, Acc)->
-    gen_inlined_enc_funs1(Erule, Fields, T, ObjSetName, Sep, NthObj, Acc);
-gen_inlined_enc_funs1(_, _, [], _, _, NthObj, Acc) ->
-    emit([nl,indent(6),"end",nl,
-	  indent(3),"end"]),
-    {Acc,NthObj}.
-
-emit_inner_of_fun(Erule, #typedef{name={ExtMod,Name},typespec=Type}=TDef,
-		  InternalDefFunName) ->
-    case {ExtMod,Name} of
-	{primitive,bif} ->
-	    emit(indent(12)),
-	    gen_encode_prim(Erule, Type, "Val"),
-	    {[],0};
-	{constructed,bif} ->
-	    emit([indent(12),"'enc_",
-		  InternalDefFunName,"'(Val)"]),
-	    {[TDef#typedef{name=InternalDefFunName}],1};
-	_ ->
-	    emit({indent(12),"'",ExtMod,"':'enc_",Name,"'(Val)"}),
-	    {[],0}
-    end;
-emit_inner_of_fun(_Erule, #typedef{name=Name}, _) ->
-    emit({indent(12),"'enc_",Name,"'(Val)"}),
-    {[],0};
-emit_inner_of_fun(Erule, #type{}=Type, _) ->
-    CurrMod = get(currmod),
-    case Type#type.def of
-	Def when is_atom(Def) ->
-	    emit({indent(9),Def," ->",nl,indent(12)}),
-	    gen_encode_prim(Erule, Type, "Val");
-	#'Externaltypereference'{module=CurrMod,type=T} ->
-	    emit({indent(9),T," ->",nl,indent(12),"'enc_",T,"'(Val)"});
-	#'Externaltypereference'{module=ExtMod,type=T} ->
-	    emit({indent(9),T," ->",nl,indent(12),ExtMod,":'enc_",
-		  T,"'(Val)"})
-    end,
-    {[],0}.
-
-indent(N) ->
-    lists:duplicate(N,32). % 32 = space
-
-
-gen_objset_dec(_, _, {unique,undefined}, _, _, _, _) ->
-    %% There is no unique field in the class of this object set
-    %% don't bother about the constraint
-    ok;
-gen_objset_dec(Erule, ObjSName, UniqueName, [{ObjName,Val,Fields}|T], ClName,
-	       ClFields, NthObj)->
-    emit({"'getdec_",ObjSName,"'(",{asis,UniqueName},",",{asis,Val},
-	  ") ->",nl}),
-    CurrMod = get(currmod),
-    NewNthObj=
-	case ObjName of
-	    {no_mod,no_name} ->
-		gen_inlined_dec_funs(Erule, Fields, ClFields,
-				     ObjSName, NthObj);
-	    {CurrMod,Name} ->
-		emit(["    fun 'dec_",Name,"'/4"]),
-		NthObj;
-	    {ModName,Name} ->
-		emit_ext_decfun(ModName,Name),
-		NthObj;
-	    _Other ->
-		emit({"    fun 'dec_",ObjName,"'/4"}),
-		NthObj
-    end,
-    emit({";",nl}),
-    gen_objset_dec(Erule, ObjSName, UniqueName, T, ClName, ClFields, NewNthObj);
-gen_objset_dec(_Erule, ObjSetName, _UniqueName, ['EXTENSIONMARK'],
-	       _ClName, _ClFields, _NthObj) ->
-    emit({"'getdec_",ObjSetName,"'(_, _) ->",nl}),
-    emit({indent(3),"fun(Attr1, Bytes, _,_) ->",nl}),
-    emit({indent(6),"{Bytes,Attr1}",nl}),
-    emit({indent(3),"end.",nl,nl}),
-    ok;
-gen_objset_dec(_Erule, ObjSetName, UniqueName, [], _, _, _) ->
-    emit_default_getdec(ObjSetName, UniqueName),
-    emit([".",nl,nl]),
+gen_objectset_code(_Erules, _ObjSet) ->
     ok.
 
-emit_ext_decfun(ModuleName,Name) ->
-    emit([indent(3),"fun(T,V,O1,O2) -> '",ModuleName,"':'dec_",
-	  Name,"'(T,V,O1,O2) end"]).
-
-emit_default_getdec(ObjSetName,UniqueName) ->
-    emit(["'getdec_",ObjSetName,"'(",{asis,UniqueName},", ErrV) ->",nl]),
-    emit([indent(2), "fun(C,V,_,_) -> exit({{component,C},{value,V},{unique_name_and_value,",{asis,UniqueName},",ErrV}}) end"]).
-
-
-gen_inlined_dec_funs(Erule, Fields, List, ObjSetName, NthObj0) ->
-    emit([indent(3),"fun(Type, Val, _, _) ->",nl,
-	  indent(6),"case Type of",nl]),
-    NthObj = gen_inlined_dec_funs1(Erule, Fields, List,
-				   ObjSetName, "", NthObj0),
-    emit([nl,indent(6),"end",nl,
-	  indent(3),"end"]),
-    NthObj.
-
-gen_inlined_dec_funs1(Erule, Fields, [{typefield,Name,_}|Rest],
-		      ObjSetName, Sep0, NthObj) ->
-    InternalDefFunName = [NthObj,Name,ObjSetName],
-    emit(Sep0),
-    Sep = [";",nl],
-    N = case lists:keyfind(Name, 1, Fields) of
-	    {_,#type{}=Type} ->
-		emit_inner_of_decfun(Erule, Type, InternalDefFunName);
-	    {_,#typedef{}=Type} ->
-		emit([indent(9),{asis,Name}," ->",nl]),
-		emit_inner_of_decfun(Erule, Type, InternalDefFunName);
-	    {_,#'Externaltypereference'{}=Etype} ->
-		emit([indent(9),{asis,Name}," ->",nl,
-		      indent(12)]),
-		gen_dec_external(Etype, "Val"),
-		0;
-	    false ->
-		emit([indent(9),{asis,Name}," -> {Val,Type}"]),
-		0
-	end,
-    gen_inlined_dec_funs1(Erule, Fields, Rest, ObjSetName, Sep, NthObj+N);
-gen_inlined_dec_funs1(Erule, Fields, [_|Rest], ObjSetName, Sep, NthObj) ->
-    gen_inlined_dec_funs1(Erule, Fields, Rest, ObjSetName, Sep, NthObj);
-gen_inlined_dec_funs1(_, _, [], _, _, NthObj) -> NthObj.
-
-emit_inner_of_decfun(Erule, #typedef{name={ExtName,Name},typespec=Type},
-		     InternalDefFunName) ->
-    case {ExtName,Name} of
-	{primitive,bif} ->
-	    emit(indent(12)),
-	    gen_dec_prim(Erule, Type, "Val"),
-	    0;
-	{constructed,bif} ->
-	    emit({indent(12),"'dec_",
-		  asn1ct_gen:list2name(InternalDefFunName),"'(Val)"}),
-	    1;
-	_ ->
-	    emit({indent(12),"'",ExtName,"':'dec_",Name,"'(Val, telltype)"}),
-	    0
-    end;
-emit_inner_of_decfun(_Erule, #typedef{name=Name}, _) ->
-    emit({indent(12),"'dec_",Name,"'(Val, telltype)"}),
-    0;
-emit_inner_of_decfun(Erule, #type{}=Type, _) ->
-    CurrMod = get(currmod),
-    case Type#type.def of
-	Def when is_atom(Def) ->
-	    emit({indent(9),Def," ->",nl,indent(12)}),
-	    gen_dec_prim(Erule, Type, "Val");
-	#'Externaltypereference'{module=CurrMod,type=T} ->
-	    emit({indent(9),T," ->",nl,indent(12),"'dec_",T,"'(Val)"});
-	#'Externaltypereference'{module=ExtMod,type=T} ->
-	    emit({indent(9),T," ->",nl,indent(12),ExtMod,":'dec_",
-		  T,"'(Val)"})
-    end,
-    0.
-
-
-gen_internal_funcs(_,[]) ->
-    ok;
-gen_internal_funcs(Erules,[TypeDef|Rest]) ->
-    gen_encode_user(Erules,TypeDef),
-    emit([nl,nl,"'dec_",TypeDef#typedef.name,"'(Bytes) ->",nl]),
-    gen_decode_user(Erules,TypeDef),
-    gen_internal_funcs(Erules,Rest).
-
-
-
 %% DECODING *****************************
 %%***************************************
 
-gen_decode(Erules,Type) when is_record(Type,typedef) ->
-    D = Type,
-    emit({nl,nl}),
-    emit({"'dec_",Type#typedef.name,"'(Bytes,_) ->",nl}),
+gen_decode(Erules, #typedef{}=Type) ->
+    DecFunc = dec_func(Type#typedef.name),
+    emit([nl,nl,{asis,DecFunc},"(Bytes) ->",nl]),
     dbdec(Type#typedef.name),
-    gen_decode_user(Erules,D).
+    gen_decode_user(Erules, Type).
 
 gen_decode(Erules,Tname,#'ComponentType'{name=Cname,typespec=Type}) ->
     NewTname = [Cname|Tname],
@@ -944,8 +242,9 @@ gen_decode(Erules,Typename,Type) when is_record(Type,type) ->
 		    _ ->
 			""
 		end,
-	    emit({nl,"'dec_",asn1ct_gen:list2name(Typename),
-		  "'(Bytes,_",ObjFun,") ->",nl}),
+	    emit([nl,
+		  {asis,dec_func(asn1ct_gen:list2name(Typename))},
+		  "(Bytes",ObjFun,") ->",nl]),
 	    dbdec(Typename),
 	    asn1ct_gen:gen_decode_constructed(Erules,Typename,InnerType,Type);
 	_ ->
@@ -982,8 +281,8 @@ gen_dec_external(Ext, BytesVar) ->
     #'Externaltypereference'{module=Mod,type=Type} = Ext,
     emit([case CurrMod of
 	      Mod -> [];
-	      _ -> ["'",Mod,"':"]
-	  end,"'dec_",Type,"'(",BytesVar,",telltype)"]).
+	      _ -> [{asis,Mod},":"]
+	  end,{asis,dec_func(Type)},"(",BytesVar,")"]).
 
 gen_dec_imm(Erule, #type{def=Name,constraint=C}) ->
     Aligned = case Erule of
@@ -1050,7 +349,10 @@ gen_dec_imm_1('GeneralizedTime', Constraint, Aligned) ->
 gen_dec_imm_1('OCTET STRING', Constraint, Aligned) ->
     SzConstr = asn1ct_imm:effective_constraint(bitstring, Constraint),
     Imm = asn1ct_imm:per_dec_octet_string(SzConstr, Aligned),
-    {convert,binary_to_list,Imm};
+    case asn1ct:use_legacy_types() of
+	false -> {convert,{binary,copy},Imm};
+	true -> {convert,binary_to_list,Imm}
+    end;
 gen_dec_imm_1('TeletexString', _Constraint, Aligned) ->
     gen_dec_restricted_string(Aligned);
 gen_dec_imm_1('T61String', _Constraint, Aligned) ->
@@ -1103,35 +405,6 @@ gen_dec_prim(Erule, Type, BytesVar) ->
     Imm = gen_dec_imm(Erule, Type),
     asn1ct_imm:dec_code_gen(Imm, BytesVar).
 
-is_already_generated(Operation,Name) ->
-    case get(class_default_type) of
-	undefined ->
-	    put(class_default_type,[{Operation,Name}]),
-	    false;
-	GeneratedList ->
-	    case lists:member({Operation,Name},GeneratedList) of
-		true ->
-		    true;
-		false ->
-		    put(class_default_type,[{Operation,Name}|GeneratedList]),
-		    false
-	    end
-    end.
-
-get_class_fields(#classdef{typespec=ObjClass}) ->
-    ObjClass#objectclass.fields;
-get_class_fields(#objectclass{fields=Fields}) ->
-    Fields;
-get_class_fields(_) ->
-    [].
-
-
-get_object_field(Name,ObjectFields) ->
-    case lists:keysearch(Name,1,ObjectFields) of
-	{value,Field} -> Field;
-	false -> false
-    end.
-
 
 %% For PER the ExtensionAdditionGroup notation has significance for the encoding and decoding
 %% the components within the ExtensionAdditionGroup is treated in a similar way as if they
@@ -1170,11 +443,8 @@ imm_dec_open_type_1(Type, Aligned) ->
 		asn1ct_name:new(tmpval),
 		emit(["begin",nl,
 		      "{",{curr,tmpval},",_} = ",
-		      "dec_",Type,"(",OpenType,", mandatory),",nl,
+		      {asis,dec_func(Type)},"(",OpenType,"),",nl,
 		      "{",{curr,tmpval},com,Buf,"}",nl,
 		      "end"])
 	end,
     {call,D,asn1ct_imm:per_dec_open_type(Aligned)}.
-
-eval_module(per) -> asn1ct_eval_per;
-eval_module(uper) -> asn1ct_eval_uper.
diff --git a/lib/asn1/src/asn1ct_gen_per_rt2ct.erl b/lib/asn1/src/asn1ct_gen_per_rt2ct.erl
deleted file mode 100644
index 012d54e7a1..0000000000
--- a/lib/asn1/src/asn1ct_gen_per_rt2ct.erl
+++ /dev/null
@@ -1,461 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2002-2013. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-%%
--module(asn1ct_gen_per_rt2ct).
-
-%% Handle encoding of primitives for aligned PER.
-
--include("asn1_records.hrl").
-
--export([gen_encode_prim/3]).
-
--import(asn1ct_gen, [emit/1,demit/1]).
--import(asn1ct_func, [call/3]).
-
-gen_encode_prim(Erules, #type{}=D, Value) ->
-    Constraint = D#type.constraint,
-    case D#type.def of
-	'INTEGER' ->
-	    EffectiveConstr = effective_constraint(integer,Constraint),
-	    emit(["  %%INTEGER with effective constraint: ",
-		  {asis,EffectiveConstr},nl]),
-	    emit_enc_integer(Erules,EffectiveConstr,Value);
-	{'INTEGER',NamedNumberList} ->
-	    EffectiveConstr = effective_constraint(integer,Constraint),
-	    %% maybe an emit_enc_NNL_integer
-	    emit(["  %%INTEGER with effective constraint: ",
-		  {asis,EffectiveConstr},nl]),
-	    emit_enc_integer_NNL(Erules,EffectiveConstr,Value,NamedNumberList);
-	'REAL' ->
-	    emit_enc_real(Erules, Value);
-
-	{'BIT STRING',NamedNumberList} ->
-	    EffectiveC = effective_constraint(bitstring,Constraint),
-	    case EffectiveC of
-		0 ->
-		    emit({"[]"});
-		_ ->
-		    call(Erules, encode_bit_string,
-			 [{asis,EffectiveC},Value,
-			  {asis,NamedNumberList}])
-	    end;
-	'NULL' ->
-	    emit("[]");
-	'OBJECT IDENTIFIER' ->
-	    call(Erules, encode_object_identifier, [Value]);
-	'RELATIVE-OID' ->
-	    call(Erules, encode_relative_oid, [Value]);
-	'ObjectDescriptor' ->
-	    call(Erules, encode_ObjectDescriptor,
-		 [{asis,Constraint},Value]);
-	'BOOLEAN' ->
-	    emit({"case ",Value," of",nl,
-		  "  true -> [1];",nl,
-		  "  false -> [0];",nl,
-		  "  _ -> exit({error,{asn1,{encode_boolean,",Value,"}}})",nl,
-		  "end"});
-	'OCTET STRING' ->
-	    emit_enc_octet_string(Erules,Constraint,Value);
-
-	'NumericString' ->
-	    emit_enc_known_multiplier_string('NumericString',Constraint,Value);
-	TString when TString == 'TeletexString';
-		     TString == 'T61String' ->
-	    call(Erules, encode_TeletexString, [{asis,Constraint},Value]);
-	'VideotexString' ->
-	    call(Erules, encode_VideotexString, [{asis,Constraint},Value]);
-	'UTCTime' ->
-	    emit_enc_known_multiplier_string('VisibleString',Constraint,Value);
-	'GeneralizedTime' ->
-	    emit_enc_known_multiplier_string('VisibleString',Constraint,Value);
-	'GraphicString' ->
-	    call(Erules, encode_GraphicString, [{asis,Constraint},Value]);
-	'VisibleString' ->
-	    emit_enc_known_multiplier_string('VisibleString',Constraint,Value);
-	'GeneralString' ->
-	    call(Erules, encode_GeneralString, [{asis,Constraint},Value]);
-	'PrintableString' ->
-	    emit_enc_known_multiplier_string('PrintableString',Constraint,Value);
-	'IA5String' ->
-	    emit_enc_known_multiplier_string('IA5String',Constraint,Value);
-	'BMPString' ->
-	    emit_enc_known_multiplier_string('BMPString',Constraint,Value);
-	'UniversalString' ->
-	    emit_enc_known_multiplier_string('UniversalString',Constraint,Value);
-	'UTF8String' ->
-	    call(Erules, encode_UTF8String, [Value]);
-	'ASN1_OPEN_TYPE' ->
-	    NewValue = case Constraint of
-			   [#'Externaltypereference'{type=Tname}] ->
-			       asn1ct_func:need({Erules,complete,1}),
-			       io_lib:format(
-				 "complete(enc_~s(~s))",[Tname,Value]);
-			   [#type{def=#'Externaltypereference'{type=Tname}}] ->
-			       asn1ct_func:need({Erules,complete,1}),
-			       io_lib:format(
-				 "complete(enc_~s(~s))",
-				 [Tname,Value]);
-			   _ ->
-			       io_lib:format("iolist_to_binary(~s)",
-					     [Value])
-		     end,
-	    call(Erules, encode_open_type, [NewValue])
-    end.
-
-emit_enc_real(Erules, Real) ->
-    asn1ct_name:new(tmpval),
-    asn1ct_name:new(tmplen),
-    emit(["begin",nl,
-	  "{",{curr,tmpval},com,{curr,tmplen},"} = ",
-	  {call,real_common,encode_real,[Real]},com,nl,
-	  "[",{call,Erules,encode_length,[{curr,tmplen}]},",",nl,
-	  {call,Erules,octets_to_complete,
-	   [{curr,tmplen},{curr,tmpval}]},"]",nl,
-	  "end"]).
-
-emit_enc_known_multiplier_string(StringType,C,Value) ->
-    SizeC = effective_constraint(bitstring, C),
-    PAlphabC = get_constraint(C,'PermittedAlphabet'),
-    case {StringType,PAlphabC} of
-	{'UniversalString',{_,_}} ->
-	    exit({error,{asn1,{'not implemented',"UniversalString with "
-			       "PermittedAlphabet constraint"}}});
-	{'BMPString',{_,_}} ->
-	    exit({error,{asn1,{'not implemented',"BMPString with "
-			       "PermittedAlphabet constraint"}}});
-	_ -> ok
-    end,
-    NumBits = get_NumBits(C,StringType),
-    CharOutTab = get_CharOutTab(C,StringType),
-    %% NunBits and CharOutTab for chars_encode
-    emit_enc_k_m_string(SizeC, NumBits, CharOutTab, Value).
-
-emit_enc_k_m_string(0, _NumBits, _CharOutTab, _Value) ->
-    emit({"[]"});
-emit_enc_k_m_string(SizeC, NumBits, CharOutTab, Value) ->
-    call(per, encode_known_multiplier_string,
-	 [{asis,SizeC},NumBits,{asis,CharOutTab},Value]).
-
-
-%% copied from run time module
-
-get_CharOutTab(C, StringType) ->
-    case get_constraint(C,'PermittedAlphabet') of
-	{'SingleValue',Sv} ->
-	    get_CharTab2(C, StringType, hd(Sv), lists:max(Sv), Sv);
-	no ->
-	    case StringType of
-		'IA5String' ->
-		    {0,16#7F,notab};
-		'VisibleString' ->
-		    get_CharTab2(C, StringType, 16#20, 16#7F, notab);
-		'PrintableString' ->
-		    Chars = lists:sort(
-			      " '()+,-./0123456789:=?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"),
-		    get_CharTab2(C, StringType, hd(Chars),
-				 lists:max(Chars), Chars);
-		'NumericString' ->
-		    get_CharTab2(C, StringType, 16#20, $9, " 0123456789");
-		'UniversalString' ->
-		    {0,16#FFFFFFFF,notab};
-		'BMPString' ->
-		    {0,16#FFFF,notab}
-	    end
-    end.
-
-get_CharTab2(C, StringType, Min, Max, Chars) ->
-    BitValMax = (1 bsl get_NumBits(C,StringType))-1,
-    if
-	Max =< BitValMax ->
-	    {0,Max,notab};
-	true ->
-	    {Min,Max,create_char_tab(Min,Chars)}
-    end.
-
-create_char_tab(Min,L) ->
-    list_to_tuple(create_char_tab(Min,L,0)).
-create_char_tab(Min,[Min|T],V) ->
-    [V|create_char_tab(Min+1,T,V+1)];
-create_char_tab(_Min,[],_V) ->
-    [];
-create_char_tab(Min,L,V) ->
-    [false|create_char_tab(Min+1,L,V)].
-
-get_NumBits(C,StringType) ->
-    case get_constraint(C,'PermittedAlphabet') of
-	{'SingleValue',Sv} ->
-	    charbits(length(Sv),aligned);
-	no ->
-	    case StringType of
-		'IA5String' ->
-		    charbits(128,aligned); % 16#00..16#7F
-		'VisibleString' ->
-		    charbits(95,aligned); % 16#20..16#7E
-		'PrintableString' ->
-		    charbits(74,aligned); % [$\s,$',$(,$),$+,$,,$-,$.,$/,"0123456789",$:,$=,$?,$A..$Z,$a..$z
-		'NumericString' ->
-		    charbits(11,aligned); % $ ,"0123456789"
-		'UniversalString' ->
-		    32;
-		'BMPString' ->
-		    16
-	    end
-    end.
-
-charbits(NumOfChars,aligned) ->
-    case charbits(NumOfChars) of
-	1 -> 1;
-	2 -> 2;
-	B when B =< 4 -> 4;
-	B when B =< 8 -> 8;
-	B when B =< 16 -> 16; 
-	B when B =< 32 -> 32
-    end.
-
-charbits(NumOfChars) when NumOfChars =< 2 -> 1;
-charbits(NumOfChars) when NumOfChars =< 4 -> 2;
-charbits(NumOfChars) when NumOfChars =< 8 -> 3;
-charbits(NumOfChars) when NumOfChars =< 16 -> 4;
-charbits(NumOfChars) when NumOfChars =< 32 -> 5;
-charbits(NumOfChars) when NumOfChars =< 64 -> 6;
-charbits(NumOfChars) when NumOfChars =< 128 -> 7;
-charbits(NumOfChars) when NumOfChars =< 256 -> 8;
-charbits(NumOfChars) when NumOfChars =< 512 -> 9;
-charbits(NumOfChars) when NumOfChars =< 1024 -> 10;
-charbits(NumOfChars) when NumOfChars =< 2048 -> 11;
-charbits(NumOfChars) when NumOfChars =< 4096 -> 12;
-charbits(NumOfChars) when NumOfChars =< 8192 -> 13;
-charbits(NumOfChars) when NumOfChars =< 16384 -> 14;
-charbits(NumOfChars) when NumOfChars =< 32768 -> 15;
-charbits(NumOfChars) when NumOfChars =< 65536 -> 16;
-charbits(NumOfChars) when is_integer(NumOfChars) ->
-    16 + charbits1(NumOfChars bsr 16).
-
-charbits1(0) ->
-    0;
-charbits1(NumOfChars) ->
-    1 + charbits1(NumOfChars bsr 1).
-
-%% copied from run time module
-
-emit_enc_octet_string(Erules, Constraint, Value) ->
-    case effective_constraint(bitstring, Constraint) of
-	0 ->
-	    emit({"  []"});
-	1 ->
-	    asn1ct_name:new(tmpval),
-	    emit({"  begin",nl}),
-	    emit({"    [",{curr,tmpval},"] = ",Value,",",nl}),
-	    emit(["    [[10,8],",{curr,tmpval},"]",nl]),
-	    emit("  end");
-	2 ->
-	    asn1ct_name:new(tmpval),
-	    emit(["  begin",nl,
-		  "    ",{curr,tmpval}," = ",Value,",",nl,
-		  "    case length(",{curr,tmpval},") of",nl,
-		  "      2 ->",nl,
-		  "        [[45,16,2]|",{curr,tmpval},"];",nl,
-		  "      _ ->",nl,
-		  "        exit({error,{value_out_of_bounds,",
-		  {curr,tmpval},"}})",nl,
-		  "    end",nl,
-		  "  end"]);
-	Sv when is_integer(Sv), Sv < 256  ->
-	    asn1ct_name:new(tmpval),
-	    asn1ct_name:new(tmplen),
-	    emit(["  begin",nl,
-		  "    ",{curr,tmpval}," = ",Value,",",nl,
-		  "    case length(",{curr,tmpval},") of",nl,
-		  "      ",Sv,"=",{curr,tmplen}," ->",nl,
-		  "       [20,",{curr,tmplen},"|",{curr,tmpval},"];",nl,
-		  "      _ ->",nl,
-		  "       exit({error,{value_out_of_bounds,",
-		  {curr,tmpval},"}})",nl,
-		  "    end",nl,
-		  "  end"]);
-	Sv when is_integer(Sv),Sv =< 65535  ->
-	    asn1ct_name:new(tmpval),
-	    asn1ct_name:new(tmplen),
-	    emit(["  begin",nl,
-		  "    ",{curr,tmpval}," = ",Value,",",nl,
-		  "    case length(",{curr,tmpval},") of",nl,
-		  "      ",Sv,"=",{curr,tmplen}," ->",nl,
-		  "        [<<21,",{curr,tmplen},":16>>|",Value,"];",nl,
-		  "      _ ->",nl,
-		  "        exit({error,{value_out_of_bounds,",
-		  {curr,tmpval},"}})",nl,
-		  "    end",nl,
-		  "  end"]);
-	C ->
-	    call(Erules, encode_octet_string,
-		 [{asis,C},Value])
-    end.
-
-emit_enc_integer_case(Value) ->
-    case get(component_type) of
-	{true,#'ComponentType'{prop=Prop}} ->
-	    emit({"  begin",nl}),
-	    case Prop of
-		Opt when Opt=='OPTIONAL';
-			 is_tuple(Opt),element(1,Opt)=='DEFAULT' ->
-		    emit({"  case ",Value," of",nl}),
-		    ok;
-		_ ->
-		    emit({"  ",{curr,tmpval},"=",Value,",",nl}),
-		    emit({"  case ",{curr,tmpval}," of",nl}),
-		    asn1ct_name:new(tmpval)
-	    end;
-%	    asn1ct_name:new(tmpval);
-	_ ->
-	    emit({" case ",Value," of ",nl})
-    end.
-emit_enc_integer_end_case() ->    
-    case get(component_type) of
-	{true,_} ->
-	    emit({nl,"  end"}); % end of begin ... end
-	_ -> ok
-    end.
-
-
-emit_enc_integer_NNL(Erules,C,Value,NNL) ->
-    EncVal = enc_integer_NNL_cases(Value,NNL),
-    emit_enc_integer(Erules,C,EncVal).
-    
-enc_integer_NNL_cases(Value,NNL) ->
-    asn1ct_name:new(tmpval),
-    TmpVal = asn1ct_gen:mk_var(asn1ct_name:curr(tmpval)),
-    Cases=enc_integer_NNL_cases1(NNL),
-    lists:flatten(io_lib:format("(case ~s of "++Cases++
-		  "~s when is_atom(~s)->exit({error,{asn1,{namednumber,~s}}});_->~s end)",[Value,TmpVal,TmpVal,TmpVal,Value])).
-
-enc_integer_NNL_cases1([{NNo,No}|Rest]) ->
-    io_lib:format("~w->~w;",[NNo,No])++enc_integer_NNL_cases1(Rest);
-enc_integer_NNL_cases1([]) ->
-    "".
-
-emit_enc_integer(_Erule,[{'SingleValue',Int}],Value) ->
-    asn1ct_name:new(tmpval),
-    emit_enc_integer_case(Value),%    emit(["  case ",Value," of",nl]),
-    emit(["    ",Int," -> [];",nl]),
-    emit(["    ",{curr,tmpval}," ->",nl]),
-    emit(["      exit({error,{value_out_of_bounds,",{curr,tmpval},"}})",
-	  nl," end",nl]),
-    emit_enc_integer_end_case();
-
-emit_enc_integer(_Erule,[{_,{Lb,Ub},_Range,{bits,NoBs}}],Value) -> % Range =< 255
-    asn1ct_name:new(tmpval),
-    emit_enc_integer_case(Value),
-    emit(["    ",{curr,tmpval}," when ",{curr,tmpval},"=<",Ub,",",
-	  {curr,tmpval},">=",Lb," ->",nl]),
-    emit(["      [10,",NoBs,",",{curr,tmpval},"- ",Lb,"];",nl]),
-    emit(["    ",{curr,tmpval}," ->",nl]),
-    emit(["      exit({error,{value_out_of_bounds,",
-	  {curr,tmpval},"}})",nl,"  end",nl]),
-    emit_enc_integer_end_case();
-
-emit_enc_integer(_Erule,[{_,{Lb,Ub},Range,_}],Value) when Range =< 256 ->
-    asn1ct_name:new(tmpval),
-    emit_enc_integer_case(Value),
-    emit(["    ",{curr,tmpval}," when ",{curr,tmpval},"=<",Ub,",",
-	  {curr,tmpval},">=",Lb," ->",nl]),
-    emit(["      [20,1,",{curr,tmpval},"- ",Lb,"];",nl]),
-    emit(["    ",{curr,tmpval}," ->",nl]),
-    emit(["      exit({error,{value_out_of_bounds,",{curr,tmpval},"}})",
-	  nl,"  end",nl]),
-    emit_enc_integer_end_case();
-
-emit_enc_integer(_Erule,[{_,{Lb,Ub},Range,_}],Value) when Range =< 65536 ->
-    asn1ct_name:new(tmpval),
-    emit_enc_integer_case(Value),
-    emit(["    ",{curr,tmpval}," when ",{curr,tmpval},"=<",Ub,",",
-	  {curr,tmpval},">=",Lb," ->",nl]),
-    emit(["      [20,2,<<(",{curr,tmpval},"- ",Lb,"):16>>];",nl]),
-    emit(["    ",{curr,tmpval}," ->",nl]),
-    emit(["      exit({error,{value_out_of_bounds,",{curr,tmpval},"}})",
-	  nl,"  end",nl]),
-    emit_enc_integer_end_case();
-
-emit_enc_integer(Erule, [{'ValueRange',{Lb,Ub}=VR}], Value)
-  when is_integer(Lb), is_integer(Ub) ->
-    call(Erule, encode_constrained_number, [{asis,VR},Value]);
-
-emit_enc_integer(Erule, C, Value) ->
-    call(Erule, encode_integer, [{asis,C},Value]).
-
-
-get_constraint([{Key,V}],Key) ->
-    V;
-get_constraint([],_) ->
-    no;
-get_constraint(C,Key) ->
-    case lists:keysearch(Key,1,C) of
-	false ->
-	    no;
-	{value,{_,V}} -> 
-	    V
-    end.
-
-%% effective_constraint(Type,C)
-%% Type = atom()
-%% C = [C1,...]
-%% C1 = {'SingleValue',SV} | {'ValueRange',VR} | {atom(),term()}
-%% SV = integer() | [integer(),...]
-%% VR = {Lb,Ub}
-%% Lb = 'MIN' | integer()
-%% Ub = 'MAX' | integer()
-%% Returns a single value if C only has a single value constraint, and no
-%% value range constraints, that constrains to a single value, otherwise 
-%% returns a value range that has the lower bound set to the lowest value 
-%% of all single values and lower bound values in C and the upper bound to
-%% the greatest value.
-effective_constraint(integer,[C={{_,_},_}|_Rest]) -> % extension
-    [C]; %% [C|effective_constraint(integer,Rest)]; XXX what is possible ???
-effective_constraint(integer,C) ->
-    pre_encode(integer, asn1ct_imm:effective_constraint(integer, C));
-effective_constraint(bitstring,C) ->
-    asn1ct_imm:effective_constraint(bitstring, C).
-
-pre_encode(integer,[]) ->
-    [];
-pre_encode(integer,C=[{'SingleValue',_}]) ->
-    C;
-pre_encode(integer,C=[{'ValueRange',VR={Lb,Ub}}]) when is_integer(Lb),is_integer(Ub)->
-    Range = Ub-Lb+1,
-    if
-	Range =< 255 ->
-	    NoBits = no_bits(Range),
-	    [{'ValueRange',VR,Range,{bits,NoBits}}];
-	Range =< 256 ->
-	    [{'ValueRange',VR,Range,{octets,1}}];
-	Range =< 65536 ->
-	    [{'ValueRange',VR,Range,{octets,2}}];
-	true ->
-	    C
-    end;
-pre_encode(integer,C) ->
-    C.
-
-no_bits(2) -> 1;
-no_bits(N) when N=<4 -> 2;
-no_bits(N) when N=<8 -> 3;
-no_bits(N) when N=<16 -> 4;
-no_bits(N) when N=<32 -> 5;
-no_bits(N) when N=<64 -> 6;
-no_bits(N) when N=<128 -> 7;
-no_bits(N) when N=<255 -> 8.
diff --git a/lib/asn1/src/asn1ct_imm.erl b/lib/asn1/src/asn1ct_imm.erl
index bf362db843..8b96242c56 100644
--- a/lib/asn1/src/asn1ct_imm.erl
+++ b/lib/asn1/src/asn1ct_imm.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -26,6 +27,20 @@
 	 per_dec_octet_string/2,per_dec_open_type/1,per_dec_real/1,
 	 per_dec_restricted_string/1]).
 -export([per_dec_constrained/3,per_dec_normally_small_number/1]).
+-export([per_enc_bit_string/4,per_enc_legacy_bit_string/4,
+	 per_enc_boolean/2,
+	 per_enc_choice/3,per_enc_enumerated/3,
+	 per_enc_integer/3,per_enc_integer/4,
+	 per_enc_null/2,
+	 per_enc_k_m_string/4,per_enc_octet_string/3,
+	 per_enc_legacy_octet_string/3,
+	 per_enc_open_type/2,
+	 per_enc_restricted_string/3,
+	 per_enc_small_number/2]).
+-export([per_enc_extension_bit/2,per_enc_extensions/4,per_enc_optional/3]).
+-export([per_enc_sof/5]).
+-export([enc_absent/3,enc_append/1,enc_element/2]).
+-export([enc_cg/2]).
 -export([optimize_alignment/1,optimize_alignment/2,
 	 dec_slim_cg/2,dec_code_gen/2]).
 -export([effective_constraint/2]).
@@ -68,15 +83,8 @@ per_dec_enumerated(NamedList0, Aligned) ->
     Ub = length(NamedList0) - 1,
     Constraint = [{'ValueRange',{0,Ub}}],
     Int = per_dec_integer(Constraint, Aligned),
-    EnumTail = case matched_range(Int) of
-		   {0,Ub} ->
-		       %% The error case can never happen.
-		       [];
-		   _ ->
-		       [enum_error]
-	       end,
-    NamedList = per_dec_enumerated_fix_list(NamedList0, EnumTail, 0),
-    {map,Int,NamedList}.
+    NamedList = per_dec_enumerated_fix_list(NamedList0, [enum_error], 0),
+    {map,Int,opt_map(NamedList, Int)}.
 
 per_dec_enumerated(BaseNamedList, NamedListExt0, Aligned) ->
     Base = per_dec_enumerated(BaseNamedList, Aligned),
@@ -110,34 +118,23 @@ per_dec_length(no, AllowZero, Aligned) ->
 per_dec_named_integer(Constraint, NamedList0, Aligned) ->
     Int = per_dec_integer(Constraint, Aligned),
     NamedList = [{K,V} || {V,K} <- NamedList0] ++ [integer_default],
-    {map,Int,NamedList}.
+    {map,Int,opt_map(NamedList, Int)}.
 
 per_dec_k_m_string(StringType, Constraint, Aligned) ->
     SzConstr = effective_constraint(bitstring, Constraint),
     N = string_num_bits(StringType, Constraint, Aligned),
-    %% X.691 (07/2002) 27.5.7 says if the upper bound times the number
-    %% of bits is greater than or equal to 16, then the bit field should
-    %% be aligned.
-    Imm = dec_string(SzConstr, N, Aligned, fun(_, Ub) -> Ub >= 16 end),
+    Imm = dec_string(SzConstr, N, Aligned, k_m_string),
     Chars = char_tab(Constraint, StringType, N),
     convert_string(N, Chars, Imm).
 
 per_dec_octet_string(Constraint, Aligned) ->
-    dec_string(Constraint, 8, Aligned,
-	       %% Aligned unless the size is fixed and =< 16.
-	       fun(Sv, Sv) -> Sv > 16;
-		  (_, _) -> true
-	       end).
+    dec_string(Constraint, 8, Aligned, 'OCTET STRING').
 
 per_dec_raw_bitstring(Constraint, Aligned) ->
-    dec_string(Constraint, 1, Aligned,
-	       fun(Sv, Sv) -> Sv > 16;
-		  (_, _) -> true
-	       end).
+    dec_string(Constraint, 1, Aligned, 'BIT STRING').
 
 per_dec_open_type(Aligned) ->
-    {get_bits,decode_unconstrained_length(true, Aligned),
-     [8,binary,{align,Aligned}]}.
+    dec_string(no, 8, Aligned, open_type).
 
 per_dec_real(Aligned) ->
     Dec = fun(V, Buf) ->
@@ -152,26 +149,332 @@ per_dec_restricted_string(Aligned) ->
     DecLen = decode_unconstrained_length(true, Aligned),
     {get_bits,DecLen,[8,binary]}.
 
+%%%
+%%% Encoding.
+%%%
+
+per_enc_bit_string(Val, [], Constraint0, Aligned) ->
+    {B,[[],Bits]} = mk_vars([], [bits]),
+    Constraint = effective_constraint(bitstring, Constraint0),
+    B ++ [{call,erlang,bit_size,[Val],Bits}|
+	  per_enc_length(Val, 1, Bits, Constraint, Aligned, 'BIT STRING')];
+per_enc_bit_string(Val0, NNL0, Constraint0, Aligned) ->
+    {B,[Val,Bs,Bits,Positions]} = mk_vars(Val0, [bs,bits,positions]),
+    NNL = lists:keysort(2, NNL0),
+    Constraint = effective_constraint(bitstring, Constraint0),
+    ExtraArgs = case constr_min_size(Constraint) of
+		    no -> [];
+		    Lb -> [Lb]
+		end,
+    ToBs = case ExtraArgs of
+	       [] ->
+		   {call,per_common,bs_drop_trailing_zeroes,[Val]};
+	       [0] ->
+		   {call,per_common,bs_drop_trailing_zeroes,[Val]};
+	       [Lower] ->
+		   {call,per_common,adjust_trailing_zeroes,[Val,Lower]}
+	   end,
+    B ++ [{'try',
+	   [bit_string_name2pos_fun(NNL, Val)],
+	   {Positions,
+	    [{call,per_common,bitstring_from_positions,
+	      [Positions|ExtraArgs]}]},
+	   [ToBs],Bs},
+	  {call,erlang,bit_size,[Bs],Bits}|
+	  per_enc_length(Bs, 1, Bits, Constraint, Aligned, 'BIT STRING')].
+
+per_enc_legacy_bit_string(Val0, [], Constraint0, Aligned) ->
+    {B,[Val,Bs,Bits]} = mk_vars(Val0, [bs,bits]),
+    Constraint = effective_constraint(bitstring, Constraint0),
+    ExtraArgs = case constr_min_size(Constraint) of
+		    no -> [];
+		    Lb -> [Lb]
+		end,
+    B ++ [{call,per_common,to_bitstring,[Val|ExtraArgs],Bs},
+	  {call,erlang,bit_size,[Bs],Bits}|
+	  per_enc_length(Bs, 1, Bits, Constraint, Aligned, 'BIT STRING')];
+per_enc_legacy_bit_string(Val0, NNL0, Constraint0, Aligned) ->
+    {B,[Val,Bs,Bits,Positions]} = mk_vars(Val0, [bs,bits,positions]),
+    NNL = lists:keysort(2, NNL0),
+    Constraint = effective_constraint(bitstring, Constraint0),
+    ExtraArgs = case constr_min_size(Constraint) of
+		    no -> [];
+		    0 -> [];
+		    Lb -> [Lb]
+		end,
+    B ++ [{'try',
+	   [bit_string_name2pos_fun(NNL, Val)],
+	   {Positions,
+	    [{call,per_common,bitstring_from_positions,
+	      [Positions|ExtraArgs]}]},
+	   [{call,per_common,to_named_bitstring,[Val|ExtraArgs]}],Bs},
+	  {call,erlang,bit_size,[Bs],Bits}|
+	  per_enc_length(Bs, 1, Bits, Constraint, Aligned, 'BIT STRING')].
+
+per_enc_boolean(Val0, _Aligned) ->
+    {B,[Val]} = mk_vars(Val0, []),
+    B++build_cond([[{eq,Val,false},{put_bits,0,1,[1]}],
+		   [{eq,Val,true},{put_bits,1,1,[1]}]]).
+
+per_enc_choice(Val0, Cs0, _Aligned) ->
+    {B,[Val]} = mk_vars(Val0, []),
+    Cs = [[{eq,Val,Tag}|opt_choice(Imm)] || {Tag,Imm} <- Cs0],
+    B++build_cond(Cs).
+
+per_enc_enumerated(Val0, {Root,Ext}, Aligned) ->
+    {B,[Val]} = mk_vars(Val0, []),
+    Constr = enumerated_constraint(Root),
+    RootCs = per_enc_enumerated_root(Root, [{put_bits,0,1,[1]}],
+				     Val, Constr, Aligned),
+    ExtCs = per_enc_enumerated_ext(Ext, Val, Aligned),
+    B++[{'cond',RootCs++ExtCs++enumerated_error(Val)}];
+per_enc_enumerated(Val0, Root, Aligned) ->
+    {B,[Val]} = mk_vars(Val0, []),
+    Constr = enumerated_constraint(Root),
+    Cs = per_enc_enumerated_root(Root, [], Val, Constr, Aligned),
+    B++[{'cond',Cs++enumerated_error(Val)}].
+
+enumerated_error(Val) ->
+    [['_',{error,Val}]].
+
+per_enc_integer(Val0, Constraint0, Aligned) ->
+    {B,[Val]} = mk_vars(Val0, []),
+    Constraint = effective_constraint(integer, Constraint0),
+    B ++ per_enc_integer_1(Val, Constraint, Aligned).
+
+per_enc_integer(Val0, NNL, Constraint0, Aligned) ->
+    {B,[Val]} = mk_vars(Val0, []),
+    Constraint = effective_constraint(integer, Constraint0),
+    Cs = [[{eq,Val,N}|per_enc_integer_1(V, Constraint, Aligned)] ||
+	     {N,V} <- NNL],
+    case per_enc_integer_1(Val, Constraint, Aligned) of
+	[{'cond',IntCs}] ->
+	    B ++ [{'cond',Cs++IntCs}];
+	Other ->
+	    B ++ [{'cond',Cs++[['_'|Other]]}]
+    end.
+
+per_enc_null(_Val, _Aligned) ->
+    [].
+
+per_enc_k_m_string(Val0, StringType, Constraint, Aligned) ->
+    {B,[Val,Bin,Len]} = mk_vars(Val0, [bin,len]),
+    SzConstraint = effective_constraint(bitstring, Constraint),
+    Unit = string_num_bits(StringType, Constraint, Aligned),
+    Chars0 = char_tab(Constraint, StringType, Unit),
+    Enc = case Unit of
+	      16 ->
+		  {call,per_common,encode_chars_16bit,[Val],Bin};
+	      32 ->
+		  {call,per_common,encode_big_chars,[Val],Bin};
+	      8 ->
+		  {call,erlang,list_to_binary,[Val],Bin};
+	      _ ->
+		  case enc_char_tab(Chars0) of
+		      notab ->
+			  {call,per_common,encode_chars,[Val,Unit],Bin};
+		      {tab,Tab} ->
+			  {call,per_common,encode_chars,[Val,Unit,Tab],Bin};
+		      {compact_map,Map} ->
+			  {call,per_common,encode_chars_compact_map,
+			   [Val,Unit,Map],Bin}
+		  end
+	  end,
+    case Unit of
+	8 ->
+	    B ++ [Enc,{call,erlang,byte_size,[Bin],Len}];
+	_ ->
+	    B ++ [{call,erlang,length,[Val],Len},Enc]
+    end ++ per_enc_length(Bin, Unit, Len, SzConstraint, Aligned, k_m_string).
+
+per_enc_open_type(Imm0, Aligned) ->
+    Imm = case Aligned of
+	      true ->
+		  %% Temporarily make the implicit 'align' done by
+		  %% complete/1 explicit to facilitate later
+		  %% optimizations: the absence of 'align' can be used
+		  %% as an indication that complete/1 can be replaced
+		  %% with a cheaper operation such as
+		  %% iolist_to_binary/1. The redundant 'align' will be
+		  %% optimized away later.
+		  Imm0 ++ [{put_bits,0,0,[1,align]}];
+	      false ->
+		  Imm0
+	  end,
+    {[],[[],Val,Len,Bin]} = mk_vars([], [output,len,bin]),
+    [{list,Imm,Val},
+     {call,enc_mod(Aligned),complete,[Val],Bin},
+     {call,erlang,byte_size,[Bin],Len}|
+     per_enc_length(Bin, 8, Len, Aligned)].
+
+per_enc_octet_string(Bin, Constraint0, Aligned) ->
+    {B,[[],Len]} = mk_vars([], [len]),
+    Constraint = effective_constraint(bitstring, Constraint0),
+    B ++ [{call,erlang,byte_size,[Bin],Len}|
+	  per_enc_length(Bin, 8, Len, Constraint, Aligned, 'OCTET STRING')].
+
+per_enc_legacy_octet_string(Val0, Constraint0, Aligned) ->
+    {B,[Val,Bin,Len]} = mk_vars(Val0, [bin,len]),
+    Constraint = effective_constraint(bitstring, Constraint0),
+    B ++ [{call,erlang,iolist_to_binary,[Val],Bin},
+	  {call,erlang,byte_size,[Bin],Len}|
+	  per_enc_length(Bin, 8, Len, Constraint, Aligned, 'OCTET STRING')].
+
+per_enc_restricted_string(Val0, {M,F}, Aligned) ->
+    {B,[Val,Bin,Len]} = mk_vars(Val0, [bin,len]),
+    B ++ [{call,M,F,[Val],Bin},
+	  {call,erlang,byte_size,[Bin],Len}|
+	  per_enc_length(Bin, 8, Len, Aligned)].
+
+per_enc_small_number(Val, Aligned) ->
+    build_cond([[{lt,Val,64},{put_bits,Val,7,[1]}],
+		['_',{put_bits,1,1,[1]}|
+		 per_enc_unsigned(Val, Aligned)]]).
+
+per_enc_extension_bit(Val0, _Aligned) ->
+    {B,[Val]} = mk_vars(Val0, []),
+    B++build_cond([[{eq,Val,[]},{put_bits,0,1,[1]}],
+		   ['_',{put_bits,1,1,[1]}]]).
+
+per_enc_extensions(Val0, Pos0, NumBits, Aligned) when NumBits > 0 ->
+    Pos = Pos0 + 1,
+    {B,[Val,Bitmap]} = mk_vars(Val0, [bitmap]),
+    Length = per_enc_small_length(NumBits, Aligned),
+    PutBits = case NumBits of
+		  1 -> [{put_bits,1,1,[1]}];
+		  _ -> [{put_bits,Bitmap,NumBits,[1]}]
+	      end,
+    B++[{call,per_common,extension_bitmap,[Val,Pos,Pos+NumBits],Bitmap},
+	{list,[{'cond',[[{eq,Bitmap,0}],
+			['_'|Length ++ PutBits]]}],
+	 {var,"Extensions"}}].
+
+per_enc_optional(Val0, {Pos,DefVals}, _Aligned) when is_integer(Pos),
+						     is_list(DefVals) ->
+    {B,Val} = enc_element(Pos, Val0),
+    Zero = {put_bits,0,1,[1]},
+    One = {put_bits,1,1,[1]},
+    B++[{'cond',
+	 [[{eq,Val,DefVal},Zero] || DefVal <- DefVals] ++ [['_',One]]}];
+per_enc_optional(Val0, {Pos,{call,M,F,A}}, _Aligned) when is_integer(Pos) ->
+    {B,Val} = enc_element(Pos, Val0),
+    {[],[[],Tmp]} = mk_vars([], [tmp]),
+    Zero = {put_bits,0,1,[1]},
+    One = {put_bits,1,1,[1]},
+    B++[{call,M,F,[Val|A],Tmp},
+	{'cond',
+	 [[{eq,Tmp,true},Zero],['_',One]]}];
+per_enc_optional(Val0, Pos, _Aligned) when is_integer(Pos) ->
+    {B,Val} = enc_element(Pos, Val0),
+    Zero = {put_bits,0,1,[1]},
+    One = {put_bits,1,1,[1]},
+    B++[{'cond',[[{eq,Val,asn1_NOVALUE},Zero],
+		 ['_',One]]}].
+
+per_enc_sof(Val0, Constraint, ElementVar, ElementImm, Aligned) ->
+    {B,[Val,Len]} = mk_vars(Val0, [len]),
+    SzConstraint = effective_constraint(bitstring, Constraint),
+    LenImm = enc_length(Len, SzConstraint, Aligned),
+    Lc0 = [{lc,ElementImm,{var,atom_to_list(ElementVar)},Val}],
+    Lc = opt_lc(Lc0, LenImm),
+    PreBlock = B ++ [{call,erlang,length,[Val],Len}],
+    case LenImm of
+	[{'cond',[[C|Action]]}] ->
+	    PreBlock ++ [{'cond',[[C|Action++Lc]]}];
+	[{sub,_,_,_}=Sub,{'cond',[[C|Action]]}] ->
+	    PreBlock ++
+		[Sub,{'cond',[[C|Action++Lc]]}];
+	EncLen ->
+	    PreBlock ++ EncLen ++ Lc
+    end.
+
+enc_absent(Val0, {call,M,F,A}, Body) ->
+    {B,[Var,Tmp]} = mk_vars(Val0, [tmp]),
+    B++[{call,M,F,[Var|A],Tmp},
+	{'cond',
+	 [[{eq,Tmp,true}],['_'|Body]]}];
+enc_absent(Val0, AbsVals, Body) when is_list(AbsVals) ->
+    {B,[Var]} = mk_vars(Val0, []),
+    Cs = [[{eq,Var,Aval}] || Aval <- AbsVals] ++ [['_'|Body]],
+    B++build_cond(Cs).
+
+enc_append([[]|T]) ->
+    enc_append(T);
+enc_append([[{put_bits,_,_,_}|_]=Pb|[Imm|T]=T0]) ->
+    case opt_choice(Pb++Imm) of
+	[{put_bits,_,_,_}|_] ->
+	    [{block,Pb}|enc_append(T0)];
+	Opt ->
+	    enc_append([Opt|T])
+    end;
+enc_append([Imm0|[Imm1|T]=T0]) ->
+    try combine_imms(Imm0, Imm1) of
+	Imm ->
+	    enc_append([Imm|T])
+    catch
+	throw:impossible ->
+	    [{block,Imm0}|enc_append(T0)]
+    end;
+enc_append([H|T]) ->
+    [{block,H}|enc_append(T)];
+enc_append([]) -> [].
+
+enc_element(N, Val0) ->
+    {[],[Val,Dst]} = mk_vars(Val0, [element]),
+    {[{call,erlang,element,[N,Val],Dst}],Dst}.
+
+enc_cg(Imm0, false) ->
+    Imm1 = enc_cse(Imm0),
+    Imm2 = enc_pre_cg(Imm1),
+    Imm = enc_opt(Imm2),
+    enc_cg(Imm);
+enc_cg(Imm0, true) ->
+    Imm1 = enc_cse(Imm0),
+    Imm2 = enc_hoist_align(Imm1),
+    Imm3 = enc_opt_al(Imm2),
+    Imm4 = per_fixup(Imm3),
+    Imm5 = enc_pre_cg(Imm4),
+    Imm = enc_opt(Imm5),
+    enc_cg(Imm).
 
 %%%
 %%% Local functions.
 %%%
 
-dec_string(Sv, U, Aligned0, AF) when is_integer(Sv) ->
+%% is_aligned(StringType, LowerBound, UpperBound) -> boolean()
+%%     StringType = 'OCTET STRING' | 'BIT STRING' | k_m_string
+%%     LowerBound = UpperBound = number of bits
+%%  Determine whether a string should be aligned in PER.
+
+is_aligned(T, Lb, Ub) when T =:= 'OCTET STRING'; T =:= 'BIT STRING' ->
+    %% OCTET STRINGs and BIT STRINGs are aligned to a byte boundary
+    %% unless the size is fixed and less than or equal to 16 bits.
+    Lb =/= Ub orelse Lb > 16;
+is_aligned(k_m_string, _Lb, Ub) ->
+    %% X.691 (07/2002) 27.5.7 says if the upper bound times the number
+    %% of bits is greater than or equal to 16, then the bit field should
+    %% be aligned.
+    Ub >= 16.
+
+%%%
+%%% Generating the intermediate format format for decoding.
+%%%
+
+dec_string(Sv, U, Aligned0, T) when is_integer(Sv) ->
     Bits = U*Sv,
-    Aligned = Aligned0 andalso AF(Bits, Bits),
+    Aligned = Aligned0 andalso is_aligned(T, Bits, Bits),
     {get_bits,Sv,[U,binary,{align,Aligned}]};
-dec_string({{Sv,Sv},[]}, U, Aligned, AF) ->
-    bit_case(dec_string(Sv, U, Aligned, AF),
-	     dec_string(no, U, Aligned, AF));
-dec_string({{_,_}=C,[]}, U, Aligned, AF) ->
-    bit_case(dec_string(C, U, Aligned, AF),
-	     dec_string(no, U, Aligned, AF));
-dec_string({Lb,Ub}, U, Aligned0, AF) ->
+dec_string({{Sv,Sv},[]}, U, Aligned, T) ->
+    bit_case(dec_string(Sv, U, Aligned, T),
+	     dec_string(no, U, Aligned, T));
+dec_string({{_,_}=C,[]}, U, Aligned, T) ->
+    bit_case(dec_string(C, U, Aligned, T),
+	     dec_string(no, U, Aligned, T));
+dec_string({Lb,Ub}, U, Aligned0, T) ->
     Len = per_dec_constrained(Lb, Ub, Aligned0),
-    Aligned = Aligned0 andalso AF(Lb*U, Ub*U),
+    Aligned = Aligned0 andalso is_aligned(T, Lb*U, Ub*U),
     {get_bits,Len,[U,binary,{align,Aligned}]};
-dec_string(_, U, Aligned, _AF) ->
+dec_string(_, U, Aligned, _T) ->
     Al = [{align,Aligned}],
     DecRest = fun(V, Buf) ->
 		      asn1ct_func:call(per_common,
@@ -197,6 +500,8 @@ per_dec_enumerated_fix_list([], Tail, _) -> Tail.
 
 per_dec_integer_1([{'SingleValue',Value}], _Aligned) ->
     {value,Value};
+per_dec_integer_1([{'ValueRange',{'MIN',_}}], Aligned) ->
+    per_dec_unconstrained(Aligned);
 per_dec_integer_1([{'ValueRange',{Lb,'MAX'}}], Aligned) when is_integer(Lb) ->
     per_decode_semi_constrained(Lb, Aligned);
 per_dec_integer_1([{'ValueRange',{Lb,Ub}}], Aligned) when is_integer(Lb),
@@ -279,14 +584,42 @@ per_num_bits(N) when N =< 64 -> 6;
 per_num_bits(N) when N =< 128 -> 7;
 per_num_bits(N) when N =< 255 -> 8.
 
+opt_map(Map, Imm) ->
+    case matched_range(Imm) of
+	unknown -> Map;
+	{Lb,Ub} -> opt_map_1(Map, Lb, Ub)
+    end.
+
+opt_map_1([{I,_}=Pair|T], Lb, Ub) ->
+    if
+	I =:= Lb, I =< Ub ->
+	    [Pair|opt_map_1(T, Lb+1, Ub)];
+	Lb < I, I =< Ub ->
+	    [Pair|opt_map_1(T, Lb, Ub)];
+	true ->
+	    opt_map_1(T, Lb, Ub)
+    end;
+opt_map_1(Map, Lb, Ub) ->
+    if
+	Lb =< Ub ->
+	    Map;
+	true ->
+	    []
+    end.
+
 matched_range({get_bits,Bits0,[U|Flags]}) when is_integer(U) ->
-    case lists:member(signed, Flags) of
-	false ->
+    case not lists:member(signed, Flags) andalso is_integer(Bits0) of
+	true ->
 	    Bits = U*Bits0,
 	    {0,(1 bsl Bits) - 1};
-	true ->
+	false ->
 	    unknown
     end;
+matched_range({add,Imm,Add}) ->
+    case matched_range(Imm) of
+	unknown -> unknown;
+	{Lb,Ub} -> {Lb+Add,Ub+Add}
+    end;
 matched_range(_Op) -> unknown.
 
 string_num_bits(StringType, Constraint, Aligned) ->
@@ -608,6 +941,9 @@ dcg_list_outside([{call,Fun,{V,Buf},{Dst,DstBuf}}|T]) ->
     emit(["{",Dst,",",DstBuf,"}  = "]),
     Fun(V, Buf),
     iter_dcg_list_outside(T);
+dcg_list_outside([{convert,{M,F},V,Dst}|T]) ->
+    emit([Dst," = ",{asis,M},":",{asis,F},"(",V,")"]),
+    iter_dcg_list_outside(T);
 dcg_list_outside([{convert,Op,V,Dst}|T]) ->
     emit([Dst," = ",Op,"(",V,")"]),
     iter_dcg_list_outside(T);
@@ -692,6 +1028,1706 @@ mk_dest(I) when is_integer(I) ->
     integer_to_list(I);
 mk_dest(S) -> S.
 
+%%%
+%%% Constructing the intermediate format for encoding.
+%%%
+
+split_off_nonbuilding(Imm) ->
+    lists:splitwith(fun is_nonbuilding/1, Imm).
+
+is_nonbuilding({assign,_,_}) -> true;
+is_nonbuilding({call,_,_,_,_}) -> true;
+is_nonbuilding({lc,_,_,_,_}) -> true;
+is_nonbuilding({set,_,_}) -> true;
+is_nonbuilding({list,_,_}) -> true;
+is_nonbuilding({sub,_,_,_}) -> true;
+is_nonbuilding({'try',_,_,_,_}) -> true;
+is_nonbuilding(_) -> false.
+
+mk_vars(Input0, Temps) ->
+    asn1ct_name:new(enc),
+    Curr = asn1ct_name:curr(enc),
+    [H|T] = atom_to_list(Curr),
+    Base = [H - ($a - $A)|T ++ "@"],
+    case Input0 of
+	{var,Name} when is_list(Name) ->
+	    {[],[Input0|mk_vars_1(Base, Temps)]};
+	[] ->
+	    {[],[Input0|mk_vars_1(Base, Temps)]};
+	_ when is_integer(Input0) ->
+	    {[],[Input0|mk_vars_1(Base, Temps)]}
+    end.
+
+mk_vars_1(Base, Vars) ->
+    [mk_var(Base, V) || V <- Vars].
+
+mk_var(Base, V) ->
+    {var,Base ++ atom_to_list(V)}.
+
+per_enc_integer_1(Val, [], Aligned) ->
+    [{'cond',[['_'|per_enc_unconstrained(Val, Aligned)]]}];
+per_enc_integer_1(Val, [{{'SingleValue',[_|_]=Svs}=Constr,[]}], Aligned) ->
+    %% An extensible constraint such as (1|17, ...).
+    %%
+    %% A subtle detail is that the extension root as described in the
+    %% ASN.1 spec should be used to determine whether a particular value
+    %% belongs to the extension root (as opposed to the effective
+    %% constraint, which will be used for the actual encoding).
+    %%
+    %% So for the example above, only the integers 1 and 17 should be
+    %% encoded as root values (extension bit = 0).
+
+    [{'ValueRange',{Lb,Ub}}] = effective_constraint(integer, [Constr]),
+    Root = [begin
+		{[],_,Put} = per_enc_constrained(Sv, Lb, Ub, Aligned),
+		[{eq,Val,Sv},{put_bits,0,1,[1]}|Put]
+	    end || Sv <- Svs],
+    Cs = Root ++ [['_',{put_bits,1,1,[1]}|
+		   per_enc_unconstrained(Val, Aligned)]],
+    build_cond(Cs);
+per_enc_integer_1(Val0, [{{_,_}=Constr,[]}], Aligned) ->
+    {Prefix,Check,Action} = per_enc_integer_2(Val0, Constr, Aligned),
+    Prefix++build_cond([[Check,{put_bits,0,1,[1]}|Action],
+			['_',{put_bits,1,1,[1]}|
+			 per_enc_unconstrained(Val0, Aligned)]]);
+per_enc_integer_1(Val0, [Constr], Aligned) ->
+    {Prefix,Check,Action} = per_enc_integer_2(Val0, Constr, Aligned),
+    Prefix++build_cond([[Check|Action],
+			['_',{error,Val0}]]).
+
+per_enc_integer_2(Val, {'SingleValue',Sv}, Aligned) when is_integer(Sv) ->
+    per_enc_constrained(Val, Sv, Sv, Aligned);
+per_enc_integer_2(Val, {'ValueRange',{'MIN',Ub}}, Aligned)
+  when is_integer(Ub) ->
+    {[],{lt,Val,Ub+1},per_enc_unconstrained(Val, Aligned)};
+per_enc_integer_2(Val0, {'ValueRange',{Lb,'MAX'}}, Aligned)
+  when is_integer(Lb) ->
+    {Prefix,Val} = sub_lb(Val0, Lb),
+    {Prefix,{ge,Val,0},per_enc_unsigned(Val, Aligned)};
+per_enc_integer_2(Val, {'ValueRange',{Lb,Ub}}, Aligned)
+  when is_integer(Lb), is_integer(Ub) ->
+    per_enc_constrained(Val, Lb, Ub, Aligned).
+
+per_enc_constrained(Val, Sv, Sv, _Aligned) ->
+    {[],{eq,Val,Sv},[]};
+per_enc_constrained(Val0, Lb, Ub, false) ->
+    {Prefix,Val} = sub_lb(Val0, Lb),
+    Range = Ub - Lb + 1,
+    NumBits = uper_num_bits(Range),
+    Check = {ult,Val,Range},
+    Put = [{put_bits,Val,NumBits,[1]}],
+    {Prefix,Check,Put};
+per_enc_constrained(Val0, Lb, Ub, true) ->
+    {Prefix,Val} = sub_lb(Val0, Lb),
+    Range = Ub - Lb + 1,
+    Check = {ult,Val,Range},
+    if
+	Range < 256 ->
+	    NumBits = per_num_bits(Range),
+	    Put = [{put_bits,Val,NumBits,[1]}],
+	    {Prefix,Check,Put};
+	Range =:= 256 ->
+	    NumBits = 8,
+	    Put = [{put_bits,Val,NumBits,[1,align]}],
+	    {Prefix,Check,Put};
+	Range =< 65536 ->
+	    Put = [{put_bits,Val,16,[1,align]}],
+	    {Prefix,Check,Put};
+	true ->
+	    RangeOctsLen = byte_size(binary:encode_unsigned(Range - 1)),
+	    BitsNeeded = per_num_bits(RangeOctsLen),
+	    {Prefix,Check,per_enc_constrained_huge(BitsNeeded, Val)}
+    end.
+
+per_enc_constrained_huge(BitsNeeded, {var,VarBase}=Val) ->
+    Bin = {var,VarBase++"@bin"},
+    BinSize0 = {var,VarBase++"@bin_size0"},
+    BinSize = {var,VarBase++"@bin_size"},
+    [{call,binary,encode_unsigned,[Val],Bin},
+     {call,erlang,byte_size,[Bin],BinSize0},
+     {sub,BinSize0,1,BinSize},
+     {'cond',[['_',
+	       {put_bits,BinSize,BitsNeeded,[1]},
+	       {put_bits,Bin,binary,[8,align]}]]}];
+per_enc_constrained_huge(BitsNeeded, Val) when is_integer(Val) ->
+    Bin = binary:encode_unsigned(Val),
+    BinSize = erlang:byte_size(Bin),
+    [{put_bits,BinSize-1,BitsNeeded,[1]},
+     {put_bits,Val,8*BinSize,[1,align]}].
+
+per_enc_unconstrained(Val, Aligned) ->
+    case Aligned of
+	false -> [];
+	true -> [{put_bits,0,0,[1,align]}]
+    end ++ [{call,per_common,encode_unconstrained_number,[Val]}].
+
+per_enc_unsigned(Val, Aligned) ->
+    case is_integer(Val) of
+	false ->
+	    {var,VarBase} = Val,
+	    Bin = {var,VarBase++"@bin"},
+	    BinSize = {var,VarBase++"@bin_size"},
+	    [{call,binary,encode_unsigned,[Val],Bin},
+	     {call,erlang,byte_size,[Bin],BinSize}|
+	     per_enc_length(Bin, 8, BinSize, Aligned)];
+	true ->
+	    Bin = binary:encode_unsigned(Val),
+	    Len = byte_size(Bin),
+	    per_enc_length(Bin, 8, Len, Aligned)
+    end.
+
+%% Encode a length field without any constraint.
+per_enc_length(Bin, Unit, Len, Aligned) ->
+    U = unit(1, Aligned),
+    PutBits = put_bits_binary(Bin, Unit, Aligned),
+    EncFragmented = {call,per_common,encode_fragmented,[Bin,Unit]},
+    Al = case Aligned of
+	     false -> [];
+	     true -> [{put_bits,0,0,[1,align]}]
+	 end,
+    build_cond([[{lt,Len,128},
+		 {put_bits,Len,8,U},PutBits],
+		[{lt,Len,16384},
+		 {put_bits,2,2,U},{put_bits,Len,14,[1]},PutBits],
+		['_'|Al++[EncFragmented]]]).
+
+per_enc_length(Bin, Unit, Len, no, Aligned, _Type) ->
+    per_enc_length(Bin, Unit, Len, Aligned);
+per_enc_length(Bin, Unit, Len, {{Lb,Ub},[]}, Aligned, Type) ->
+    {Prefix,Check,PutLen} = per_enc_constrained(Len, Lb, Ub, Aligned),
+    NoExt = {put_bits,0,1,[1]},
+    U = unit(Unit, Aligned, Type, Lb*Unit, Ub*Unit),
+    PutBits = [{put_bits,Bin,binary,U}],
+    [{'cond',ExtConds0}] = per_enc_length(Bin, Unit, Len, Aligned),
+    Ext = {put_bits,1,1,[1]},
+    ExtConds = prepend_to_cond(ExtConds0, Ext),
+    build_length_cond(Prefix, [[Check,NoExt|PutLen++PutBits]|ExtConds]);
+per_enc_length(Bin, Unit, Len, {Lb,Ub}, Aligned, Type)
+  when is_integer(Lb) ->
+    {Prefix,Check,PutLen} = per_enc_constrained(Len, Lb, Ub, Aligned),
+    U = unit(Unit, Aligned, Type, Lb*Unit, Ub*Unit),
+    PutBits = [{put_bits,Bin,binary,U}],
+    build_length_cond(Prefix, [[Check|PutLen++PutBits]]);
+per_enc_length(Bin, Unit0, Len, Sv, Aligned, Type) when is_integer(Sv) ->
+    NumBits = Sv*Unit0,
+    Unit = case NumBits rem 8 of
+	       0 ->
+		   %% Help out the alignment optimizer.
+		   8;
+	       _ ->
+		   Unit0
+	   end,
+    U = unit(Unit, Aligned, Type, NumBits, NumBits),
+    Pb = {put_bits,Bin,binary,U},
+    [{'cond',[[{eq,Len,Sv},Pb]]}].
+
+enc_length(Len, no, Aligned) ->
+    U = unit(1, Aligned),
+    build_cond([[{lt,Len,128},
+		 {put_bits,Len,8,U}],
+		[{lt,Len,16384},
+		 {put_bits,2,2,U},{put_bits,Len,14,[1]}]]);
+enc_length(Len, {{Lb,Ub},[]}, Aligned) ->
+    {Prefix,Check,PutLen} = per_enc_constrained(Len, Lb, Ub, Aligned),
+    NoExt = {put_bits,0,1,[1]},
+    [{'cond',ExtConds0}] = enc_length(Len, no, Aligned),
+    Ext = {put_bits,1,1,[1]},
+    ExtConds = prepend_to_cond(ExtConds0, Ext),
+    build_length_cond(Prefix, [[Check,NoExt|PutLen]|ExtConds]);
+enc_length(Len, {Lb,Ub}, Aligned) when is_integer(Lb) ->
+    {Prefix,Check,PutLen} = per_enc_constrained(Len, Lb, Ub, Aligned),
+    build_length_cond(Prefix, [[Check|PutLen]]);
+enc_length(Len, Sv, _Aligned) when is_integer(Sv) ->
+    [{'cond',[[{eq,Len,Sv}]]}].
+
+put_bits_binary(Bin, _Unit, Aligned) when is_binary(Bin) ->
+    Sz = byte_size(Bin),
+    <<Int:Sz/unit:8>> = Bin,
+    {put_bits,Int,8*Sz,unit(1, Aligned)};
+put_bits_binary(Bin, Unit, Aligned) ->
+    {put_bits,Bin,binary,unit(Unit, Aligned)}.
+
+sub_lb(Val, 0) ->
+    {[],Val};
+sub_lb({var,Var}=Val0, Lb) ->
+    Val = {var,Var++"@sub"},
+    {[{sub,Val0,Lb,Val}],Val};
+sub_lb(Val, Lb) when is_integer(Val) ->
+    {[],Val-Lb}.
+
+build_length_cond([{sub,Var0,Base,Var}]=Prefix, Cs) ->
+    %% Non-zero lower bound, such as: SIZE (50..200, ...)
+    Prefix++[{'cond',opt_length_nzlb(Cs, {Var0,Var,Base}, 0)}];
+build_length_cond([], Cs) ->
+    %% Zero lower bound, such as: SIZE (0..200, ...)
+    [{'cond',opt_length_zlb(Cs, 0)}].
+
+opt_length_zlb([[{ult,Var,Val}|Actions]|T], Ub) ->
+    %% Since the SIZE constraint is zero-based, Var
+    %% must be greater than zero, and we can use
+    %% the slightly cheaper signed less than operator.
+    opt_length_zlb([[{lt,Var,Val}|Actions]|T], Ub);
+opt_length_zlb([[{lt,_,Val}|_]=H|T], Ub) ->
+    if
+	Val =< Ub ->
+	    %% A previous test has already matched.
+	    opt_length_zlb(T, Ub);
+	true ->
+	    [H|opt_length_zlb(T, max(Ub, Val))]
+    end;
+opt_length_zlb([H|T], Ub) ->
+    [H|opt_length_zlb(T, Ub)];
+opt_length_zlb([], _) -> [].
+
+opt_length_nzlb([[{ult,Var,Val}|_]=H|T], {_,Var,Base}=St, _Ub) ->
+    [H|opt_length_nzlb(T, St, Base+Val)];
+opt_length_nzlb([[{lt,Var0,Val}|_]=H|T], {Var0,_,_}=St, Ub) ->
+    if
+	Val =< Ub ->
+	    %% A previous test has already matched.
+	    opt_length_nzlb(T, St, Ub);
+	true ->
+	    [H|opt_length_nzlb(T, St, Val)]
+    end;
+opt_length_nzlb([H|T], St, Ub) ->
+    [H|opt_length_nzlb(T, St, Ub)];
+opt_length_nzlb([], _, _) -> [].
+
+build_cond(Conds0) ->
+    case eval_cond(Conds0, gb_sets:empty()) of
+	[['_'|Actions]] ->
+	    Actions;
+	Conds ->
+	    [{'cond',Conds}]
+    end.
+
+eval_cond([['_',{'cond',Cs}]], Seen) ->
+    eval_cond(Cs, Seen);
+eval_cond([[Cond|Actions]=H|T], Seen0) ->
+    case gb_sets:is_element(Cond, Seen0) of
+	false ->
+	    Seen = gb_sets:insert(Cond, Seen0),
+	    case eval_cond_1(Cond) of
+		false ->
+		    eval_cond(T, Seen);
+		true ->
+		    [['_'|Actions]];
+		maybe ->
+		    [H|eval_cond(T, Seen)]
+	    end;
+	true ->
+	    eval_cond(T, Seen0)
+    end;
+eval_cond([], _) -> [].
+
+eval_cond_1({ult,I,N}) when is_integer(I), is_integer(N) ->
+    0 =< I andalso I < N;
+eval_cond_1({eq,[],[]}) ->
+    true;
+eval_cond_1({eq,I,N}) when is_integer(I), is_integer(N) ->
+    I =:= N;
+eval_cond_1({ge,I,N}) when is_integer(I), is_integer(N) ->
+    I >= N;
+eval_cond_1({lt,I,N}) when is_integer(I), is_integer(N) ->
+    I < N;
+eval_cond_1(_) -> maybe.
+
+prepend_to_cond([H|T], Code) ->
+    [prepend_to_cond_1(H, Code)|prepend_to_cond(T, Code)];
+prepend_to_cond([], _) -> [].
+
+prepend_to_cond_1([Check|T], Code) ->
+    [Check,Code|T].
+
+enc_char_tab(notab) ->
+    notab;
+enc_char_tab(Tab0) ->
+    Tab1 = tuple_to_list(Tab0),
+    First = hd(Tab1),
+    Tab = enc_char_tab_1(Tab1, First, 0),
+    case lists:member(ill, Tab) of
+	false ->
+	    {compact_map,{First,tuple_size(Tab0)}};
+	true ->
+	    {tab,{First-1,list_to_tuple(Tab)}}
+    end.
+
+enc_char_tab_1([H|T], H, I) ->
+    [I|enc_char_tab_1(T, H+1, I+1)];
+enc_char_tab_1([_|_]=T, H, I) ->
+    [ill|enc_char_tab_1(T, H+1, I)];
+enc_char_tab_1([], _, _) -> [].
+
+enumerated_constraint([_]) ->
+    [{'SingleValue',0}];
+enumerated_constraint(Root) ->
+    [{'ValueRange',{0,length(Root)-1}}].
+
+per_enc_enumerated_root(NNL, Prefix, Val, Constr, Aligned) ->
+    per_enc_enumerated_root_1(NNL, Prefix, Val, Constr, Aligned, 0).
+
+per_enc_enumerated_root_1([{H,_}|T], Prefix, Val, Constr, Aligned, N) ->
+    [[{eq,Val,H}|Prefix++per_enc_integer_1(N, Constr, Aligned)]|
+     per_enc_enumerated_root_1(T, Prefix, Val, Constr, Aligned, N+1)];
+per_enc_enumerated_root_1([], _, _, _, _, _) -> [].
+
+per_enc_enumerated_ext(NNL, Val, Aligned) ->
+    per_enc_enumerated_ext_1(NNL, Val, Aligned, 0).
+
+per_enc_enumerated_ext_1([{H,_}|T], Val, Aligned, N) ->
+    [[{eq,Val,H},{put_bits,1,1,[1]}|per_enc_small_number(N, Aligned)]|
+     per_enc_enumerated_ext_1(T, Val, Aligned, N+1)];
+per_enc_enumerated_ext_1([], _, _, _) -> [].
+
+per_enc_small_length(Val0, Aligned) ->
+    {Sub,Val} = sub_lb(Val0, 1),
+    U = unit(1, Aligned),
+    Sub ++ build_cond([[{lt,Val,64},{put_bits,Val,7,[1]}],
+		       [{lt,Val0,128},{put_bits,1,1,[1]},
+			{put_bits,Val0,8,U}],
+		       ['_',{put_bits,1,1,[1]},
+			{put_bits,2,2,U},{put_bits,Val0,14,[1]}]]).
+
+constr_min_size(no) -> no;
+constr_min_size({{Lb,_},[]}) when is_integer(Lb) -> Lb;
+constr_min_size({Lb,_}) when is_integer(Lb) -> Lb;
+constr_min_size(Sv) when is_integer(Sv) -> Sv.
+
+enc_mod(false) -> uper;
+enc_mod(true) -> per.
+
+unit(U, false) -> [U];
+unit(U, true) -> [U,align].
+
+unit(U, Aligned, Type, Lb, Ub) ->
+    case Aligned andalso is_aligned(Type, Lb, Ub) of
+	true -> [U,align];
+	false -> [U]
+    end.
+
+opt_choice(Imm) ->
+    {Pb,T0} = lists:splitwith(fun({put_bits,V,_,_}) when is_integer(V) ->
+				      true;
+				 (_) ->
+				      false
+			      end, Imm),
+    try
+	{Prefix,T} = split_off_nonbuilding(T0),
+	Prefix ++ opt_choice_1(T, Pb)
+    catch
+	throw:impossible ->
+	    Imm
+    end.
+
+opt_choice_1([{'cond',Cs0}], Pb) ->
+    case Cs0 of
+	[[C|Act]] ->
+	    [{'cond',[[C|Pb++Act]]}];
+	[[C|Act],['_',{error,_}]=Error] ->
+	    [{'cond',[[C|Pb++Act],Error]}];
+	_ ->
+	    [{'cond',opt_choice_2(Cs0, Pb)}]
+    end;
+opt_choice_1(_, _) -> throw(impossible).
+
+opt_choice_2([[C|[{put_bits,_,_,_}|_]=Act]|T], Pb) ->
+    [[C|Pb++Act]|opt_choice_2(T, Pb)];
+opt_choice_2([[_,{error,_}]=H|T], Pb) ->
+    [H|opt_choice_2(T, Pb)];
+opt_choice_2([_|_], _) ->
+    throw(impossible);
+opt_choice_2([], _) -> [].
+
+%%%
+%%% Optimize list comprehensions (SEQUENCE OF/SET OF).
+%%%
+
+opt_lc([{lc,[{call,erlang,iolist_to_binary,[Var],Bin},
+	       {call,erlang,byte_size,[Bin],LenVar},
+	       {'cond',[[{eq,LenVar,Len},{put_bits,Bin,_,[_|Align]}]]}],
+	   Var,Val}]=Lc, LenImm) ->
+    %% Given a sequence of a fixed length string, such as
+    %% SEQUENCE OF OCTET STRING (SIZE (4)), attempt to rewrite to
+    %% a list comprehension that just checks the size, followed by
+    %% a conversion to binary:
+    %%
+    %%   _ = [if length(Comp) =:= 4; byte_size(Comp) =:= 4 -> [] end ||
+    %%           Comp <- Sof],
+    %%   [align|iolist_to_binary(Sof)]
+
+    CheckImm = [{'cond',[[{eq,{expr,"length("++mk_val(Var)++")"},Len}],
+			 [{eq,{expr,"byte_size("++mk_val(Var)++")"},Len}]]}],
+    Al = case Align of
+	     [] ->
+		 [];
+	     [align] ->
+		 [{put_bits,0,0,[1|Align]}]
+	 end,
+    case Al =:= [] orelse
+	is_end_aligned(LenImm) orelse
+	lb_is_nonzero(LenImm) of
+	false ->
+	    %% Not possible because an empty SEQUENCE OF would be
+	    %% improperly aligned. Example:
+	    %%
+	    %%    SEQUENCE (SIZE (0..3)) OF ...
+
+	    Lc;
+	true ->
+	    %% Examples:
+	    %%
+	    %% SEQUENCE (SIZE (1..4)) OF ...
+	    %%   (OK because there must be at least one element)
+	    %%
+	    %% SEQUENCE OF ...
+	    %%   (OK because the length field will force alignment)
+	    %%
+	    Al ++ [{lc,CheckImm,Var,Val,{var,"_"}},
+		   {call,erlang,iolist_to_binary,[Val]}]
+    end;
+opt_lc([{lc,ElementImm0,V,L}]=Lc, LenImm) ->
+    %% Attempt to hoist the alignment, putting after the length
+    %% and before the list comprehension:
+    %%
+    %%   [Length,
+    %%    align,
+    %%    [Encode(Comp) || Comp <- Sof]]
+    %%
+
+    case enc_opt_al_1(ElementImm0, 0) of
+	{ElementImm,0} ->
+	    case is_end_aligned(LenImm) orelse
+		(is_beginning_aligned(ElementImm0) andalso
+		 lb_is_nonzero(LenImm)) of
+		false ->
+		    %% Examples:
+		    %%
+		    %% SEQUENCE (SIZE (0..3)) OF OCTET STRING
+		    %%   (An empty SEQUENCE OF would be improperly aligned)
+		    %%
+		    %% SEQUENCE (SIZE (1..3)) OF OCTET STRING (SIZE (0..4))
+		    %%   (There would be an improper alignment before the
+		    %%   first element)
+
+		    Lc;
+		true ->
+		    %% Examples:
+		    %%
+		    %% SEQUENCE OF INTEGER
+		    %% SEQUENCE (SIZE (1..4)) OF INTEGER
+		    %% SEQUENCE (SIZE (1..4)) OF INTEGER (0..256)
+
+		    [{put_bits,0,0,[1,align]},{lc,ElementImm,V,L}]
+	    end;
+	_ ->
+	    %% Unknown alignment, no alignment, or not aligned at the end.
+	    %% Examples:
+	    %%
+	    %% SEQUENCE OF SomeConstructedType
+	    %% SEQUENCE OF INTEGER (0..15)
+
+	    Lc
+    end.
+
+is_beginning_aligned([{'cond',Cs}]) ->
+    lists:all(fun([_|Act]) -> is_beginning_aligned(Act) end, Cs);
+is_beginning_aligned([{error,_}|_]) -> true;
+is_beginning_aligned([{put_bits,_,_,U}|_]) ->
+    case U of
+	[_,align] -> true;
+	[_] -> false
+    end;
+is_beginning_aligned(Imm0) ->
+    case split_off_nonbuilding(Imm0) of
+	{[],_} -> false;
+	{[_|_],Imm} -> is_beginning_aligned(Imm)
+    end.
+
+is_end_aligned(Imm) ->
+    case enc_opt_al_1(Imm, unknown) of
+	{_,0} -> true;
+	{_,_} -> false
+    end.
+
+lb_is_nonzero([{sub,_,_,_}|_]) -> true;
+lb_is_nonzero(_) -> false.
+
+%%%
+%%% Attempt to combine two chunks of intermediate code.
+%%%
+
+combine_imms(ImmA0, ImmB0) ->
+    {Prefix0,ImmA} = split_off_nonbuilding(ImmA0),
+    {Prefix1,ImmB} = split_off_nonbuilding(ImmB0),
+    Prefix = Prefix0 ++ Prefix1,
+    Combined = do_combine(ImmA ++ ImmB, 3.0),
+    Prefix ++ Combined.
+
+do_combine([{error,_}=Imm|_], _Budget) ->
+    [Imm];
+do_combine([{'cond',Cs0}|T], Budget0) ->
+    Budget = debit(Budget0, num_clauses(Cs0, 0)),
+    Cs = [[C|do_combine(Act++T, Budget)] || [C|Act] <- Cs0],
+    [{'cond',Cs}];
+do_combine([{put_bits,V,_,_}|_]=L, Budget) when is_integer(V) ->
+    {Pb,T} = collect_put_bits(L),
+    do_combine_put_bits(Pb, T,Budget);
+do_combine(_, _) ->
+    throw(impossible).
+
+do_combine_put_bits(Pb, [], _Budget) ->
+    Pb;
+do_combine_put_bits(Pb, [{'cond',Cs0}|T], Budget) ->
+    Cs = [case Act of
+	      [{error,_}] ->
+		  [C|Act];
+	      _ ->
+		  [C|do_combine(Pb++Act, Budget)]
+	  end || [C|Act] <- Cs0],
+    do_combine([{'cond',Cs}|T], Budget);
+do_combine_put_bits(_, _, _) ->
+    throw(impossible).
+
+debit(Budget0, Alternatives) ->
+    case Budget0 - math:log2(Alternatives) of
+	Budget when Budget > 0.0 ->
+	    Budget;
+	_ ->
+	    throw(impossible)
+    end.
+
+num_clauses([[_,{error,_}]|T], N) ->
+    num_clauses(T, N);
+num_clauses([_|T], N) ->
+    num_clauses(T, N+1);
+num_clauses([], N) -> N.
+
+
+collect_put_bits(Imm) ->
+    lists:splitwith(fun({put_bits,V,_,_}) when is_integer(V) -> true;
+		       (_) -> false
+		    end, Imm).
+
+%%%
+%%% Simple common subexpression elimination to avoid fetching
+%%% the same element twice.
+%%%
+
+enc_cse([{call,erlang,element,Args,V}=H|T]) ->
+    [H|enc_cse_1(T, Args, V)];
+enc_cse(Imm) -> Imm.
+
+enc_cse_1([{call,erlang,element,Args,Dst}|T], Args, V) ->
+    [{set,V,Dst}|enc_cse_1(T, Args, V)];
+enc_cse_1([{block,Bl}|T], Args, V) ->
+    [{block,enc_cse_1(Bl, Args, V)}|enc_cse_1(T, Args, V)];
+enc_cse_1([H|T], Args, V) ->
+    [H|enc_cse_1(T, Args, V)];
+enc_cse_1([], _, _) -> [].
+
+
+%%%
+%%% Pre-process the intermediate code to simplify code generation.
+%%%
+
+enc_pre_cg(Imm) ->
+    enc_pre_cg_1(Imm, outside_list, in_seq).
+
+enc_pre_cg_1([], _StL, _StB) ->
+    nil;
+enc_pre_cg_1([H], StL, StB) ->
+    enc_pre_cg_2(H, StL, StB);
+enc_pre_cg_1([H0|T0], StL, StB) ->
+    case is_nonbuilding(H0) of
+	true ->
+	    H = enc_pre_cg_nonbuilding(H0, StL),
+	    Seq = {seq,H,enc_pre_cg_1(T0, StL, in_seq)},
+	    case StB of
+		outside_seq -> {block,Seq};
+		in_seq -> Seq
+	    end;
+	false ->
+	    H = enc_pre_cg_2(H0, in_head, outside_seq),
+	    T = enc_pre_cg_1(T0, in_tail, outside_seq),
+	    enc_make_cons(H, T)
+    end.
+
+enc_pre_cg_2(align, StL, _StB) ->
+    case StL of
+	in_head -> align;
+	in_tail -> {cons,align,nil}
+    end;
+enc_pre_cg_2({apply,_,_}=Imm, _, _) ->
+    Imm;
+enc_pre_cg_2({block,Bl0}, StL, StB) ->
+    enc_pre_cg_1(Bl0, StL, StB);
+enc_pre_cg_2({call,_,_,_}=Imm, _, _) ->
+    Imm;
+enc_pre_cg_2({call_gen,_,_,_,_,_}=Imm, _, _) ->
+    Imm;
+enc_pre_cg_2({'cond',Cs0}, StL, _StB) ->
+    Cs = [{C,enc_pre_cg_1(Act, StL, outside_seq)} || [C|Act] <- Cs0],
+    {'cond',Cs};
+enc_pre_cg_2({error,_}=E, _, _) ->
+    E;
+enc_pre_cg_2({lc,B0,V,L}, StL, _StB) ->
+    B = enc_pre_cg_1(B0, StL, outside_seq),
+    {lc,B,V,L};
+enc_pre_cg_2({put_bits,V,8,[1]}, StL, _StB) ->
+    case StL of
+	in_head -> {integer,V};
+	in_tail -> {cons,{integer,V},nil};
+	outside_list -> {cons,{integer,V},nil}
+    end;
+enc_pre_cg_2({put_bits,V,binary,_}, _StL, _StB) ->
+    V;
+enc_pre_cg_2({put_bits,_,_,[_]}=PutBits, _StL, _StB) ->
+    {binary,[PutBits]};
+enc_pre_cg_2({var,_}=Imm, _, _) -> Imm.
+
+enc_make_cons({binary,H}, {binary,T}) ->
+    {binary,H++T};
+enc_make_cons({binary,H0}, {cons,{binary,H1},T}) ->
+    enc_make_cons({binary,H0++H1}, T);
+enc_make_cons({binary,H}, {cons,{integer,Int},T}) ->
+    enc_make_cons({binary,H++[{put_bits,Int,8,[1]}]}, T);
+enc_make_cons({integer,Int}, {binary,T}) ->
+    {binary,[{put_bits,Int,8,[1]}|T]};
+enc_make_cons({integer,Int}, {cons,{binary,H},T}) ->
+    enc_make_cons({binary,[{put_bits,Int,8,[1]}|H]}, T);
+enc_make_cons(H, T) ->
+    {cons,H,T}.
+
+enc_pre_cg_nonbuilding({lc,B0,Var,List,Dst}, StL) ->
+    B = enc_pre_cg_1(B0, StL, outside_seq),
+    {lc,B,Var,List,Dst};
+enc_pre_cg_nonbuilding({list,List0,Dst}, _StL) ->
+    List = enc_pre_cg_1(List0, outside_list, outside_seq),
+    {list,List,Dst};
+enc_pre_cg_nonbuilding({'try',Try0,{P,Succ0},Else0,Dst}, StL) ->
+    Try = enc_pre_cg_1(Try0, StL, outside_seq),
+    Succ = enc_pre_cg_1(Succ0, StL, outside_seq),
+    Else = enc_pre_cg_1(Else0, StL, outside_seq),
+    {'try',Try,{P,Succ},Else,Dst};
+enc_pre_cg_nonbuilding(Imm, _) -> Imm.
+
+%%%
+%%% Optimize calls to complete/1 and surrounding code. There are
+%%% several opportunities for optimizations.
+%%%
+%%% It may be possible to replace the call to complete/1 with
+%%% something cheaper (most important for the PER back-end which has
+%%% an expensive complete/1 implementation). If we can be sure that
+%%% complete/1 will be called with an iolist (no 'align' atoms or
+%%% bitstrings in the list), we can call iolist_to_binary/1
+%%% instead. If the list may include bitstrings, we can can call
+%%% list_to_bitstring/1 (note that list_to_bitstring/1 does not accept
+%%% a binary or bitstring, so we MUST be sure that we only pass it a
+%%% list).  If complete/1 is called with a binary, we can omit the
+%%% call altogether.
+%%%
+%%% A call to byte_size/1 that follows complete/1 can be eliminated
+%%% if the size of the binary produced by complete/1 can be determined
+%%% and is constant.
+%%%
+%%% The code that encodes the length descriptor (a 'cond' instruction)
+%%% for a binary produced by complete/1 can be simplified if the lower
+%%% and upper bounds for the size of the binary are known.
+%%%
+
+-record(ost,
+	{sym,
+	 t
+	}).
+
+enc_opt(Imm0) ->
+    {Imm,_} = enc_opt(Imm0, #ost{sym=gb_trees:empty()}),
+    Imm.
+
+enc_opt(align, St) ->
+    {align,St#ost{t=t_align({0,7})}};
+enc_opt({apply,What,As}, St) ->
+    {{apply,What,subst_list(As, St)},St#ost{t=t_any()}};
+enc_opt({assign,_,_}=Imm, St) ->
+    {Imm,St};
+enc_opt({binary,PutBits0}, St) ->
+    PutBits = [{put_bits,subst(V, St),Sz,F} ||
+		  {put_bits,V,Sz,F} <- PutBits0],
+    NumBits = lists:foldl(fun({put_bits,_,Bits,_}, Sum) ->
+				  Sum+Bits
+			  end, 0, PutBits),
+    {{binary,PutBits},St#ost{t=t_bitstring(NumBits)}};
+enc_opt({block,Bl0}, St0) ->
+    {Bl,St} = enc_opt(Bl0, St0),
+    {{block,Bl},St};
+enc_opt({call,binary,encode_unsigned,[Int],Bin}=Imm, St0) ->
+    Type = get_type(Int, St0),
+    St = case t_range(Type) of
+	     any ->
+		 set_type(Bin, t_binary(), St0);
+	     {Lb0,Ub0} ->
+		 Lb = bit_size(binary:encode_unsigned(Lb0)),
+		 Ub = bit_size(binary:encode_unsigned(Ub0)),
+		 set_type(Bin, t_binary({Lb,Ub}), St0)
+	 end,
+    {Imm,St};
+enc_opt({call,erlang,bit_size,[Bin],Dst}=Imm0, St0) ->
+    Type = get_type(Bin, St0),
+    case t_range(Type) of
+	any ->
+	    St1 = set_type(Bin, t_bitstring(), St0),
+	    St = propagate(Dst,
+			   fun(T, S) ->
+				   bit_size_propagate(Bin, T, S)
+			   end, St1),
+	    {Imm0,St};
+	{Lb,Ub}=Range ->
+	    St = set_type(Dst, t_integer(Range), St0),
+	    Imm = case Lb of
+		      Ub -> none;
+		      _ -> Imm0
+		  end,
+	    {Imm,St}
+    end;
+enc_opt({call,erlang,byte_size,[Bin],Dst}=Imm0, St0) ->
+    Type = get_type(Bin, St0),
+    case t_range(Type) of
+	any ->
+	    St1 = set_type(Bin, t_binary(), St0),
+	    St = propagate(Dst,
+			   fun(T, S) ->
+				   byte_size_propagate(Bin, T, S)
+			   end, St1),
+	    {Imm0,St};
+	{Lb0,Ub0} ->
+	    Lb = (Lb0+7) div 8,
+	    Ub = (Ub0+7) div 8,
+	    St = set_type(Dst, t_integer({Lb,Ub}), St0),
+	    Imm = case Lb of
+		      Ub -> none;
+		      _ -> Imm0
+		  end,
+	    {Imm,St}
+    end;
+enc_opt({call,erlang,iolist_to_binary,_}=Imm, St) ->
+    {Imm,St#ost{t=t_binary()}};
+enc_opt({call,erlang,length,[List],Dst}=Imm0, St0) ->
+    St1 = propagate(Dst,
+		    fun(T, S) ->
+			    length_propagate(List, T, S)
+		    end, St0),
+    {Imm0,St1};
+enc_opt({call,per,complete,[Data],Dst}, St0) ->
+    Type = get_type(Data, St0),
+    St = set_type(Dst, t_binary(t_range(Type)), St0),
+    case t_type(Type) of
+	binary ->
+	    {{set,Data,Dst},St};
+	bitlist ->
+	    %% We KNOW that list_to_bitstring/1 will construct
+	    %% a binary (the number of bits is divisible by 8)
+	    %% because per_enc_open_type/2 added an 'align' atom
+	    %% at the end. If that 'align' atom had not been
+	    %% optimized away, the type would have been 'align'
+	    %% instead of 'bitlist'.
+	    {{call,erlang,list_to_bitstring,[Data],Dst},St};
+	iolist ->
+	    {{call,erlang,iolist_to_binary,[Data],Dst},St};
+	nil ->
+	    Imm = {list,{binary,[{put_bits,0,8,[1]}]},Dst},
+	    enc_opt(Imm, St0);
+	_ ->
+	    {{call,per,complete,[Data],Dst},St}
+    end;
+enc_opt({call,uper,complete,[Data],Dst}, St0) ->
+    Type = get_type(Data, St0),
+    St = set_type(Dst, t_binary(t_range(Type)), St0),
+    case t_type(Type) of
+	binary ->
+	    {{set,Data,Dst},St0};
+	iolist ->
+	    {{call,erlang,iolist_to_binary,[Data],Dst},St};
+	nil ->
+	    Imm = {list,{binary,[{put_bits,0,8,[1]}]},Dst},
+	    enc_opt(Imm, St0);
+	_ ->
+	    %% 'bitlist' or 'any'.
+	    {{call,uper,complete,[Data],Dst},St}
+    end;
+enc_opt({call,per_common,encode_chars,[List,NumBits|_],Dst}=Imm, St0) ->
+    %% Note: Never used when NumBits =:= 8 (list_to_binary/1 will
+    %% be used instead).
+    St1 = set_type(Dst, t_bitstring(), St0),
+    St = propagate(List,
+		   fun(T, S) ->
+			   char_propagate(Dst, T, NumBits, S)
+		   end, St1),
+    {Imm,St};
+enc_opt({call,per_common,encode_chars_16bit,[List],Dst}=Imm, St0) ->
+    St1 = set_type(Dst, t_binary(), St0),
+    St = propagate(List,
+		   fun(T, S) ->
+			   char_propagate(Dst, T, 16, S)
+		   end, St1),
+    {Imm,St};
+enc_opt({call,per_common,encode_big_chars,[List],Dst}=Imm, St0) ->
+    St1 = set_type(Dst, t_binary(), St0),
+    St = propagate(List,
+		   fun(T, S) ->
+			   char_propagate(Dst, T, 32, S)
+		   end, St1),
+    {Imm,St};
+enc_opt({call,per_common,encode_fragmented,[_,Unit]}=Imm, St) ->
+    T = case Unit rem 8 of
+	    0 -> t_iolist();
+	    _ -> t_bitlist()
+	end,
+    {Imm,St#ost{t=T}};
+enc_opt({call,per_common,encode_unconstrained_number,_}=Imm, St) ->
+    {Imm,St#ost{t=t_iolist()}};
+enc_opt({call,per_common,bitstring_from_positions,_}=Imm, St) ->
+    {Imm,St#ost{t=t_bitstring()}};
+enc_opt({call,per_common,to_named_bitstring,_}=Imm, St) ->
+    {Imm,St#ost{t=t_bitstring()}};
+enc_opt({call,_,_,_}=Imm, St) ->
+    {Imm,St#ost{t=t_any()}};
+enc_opt({call,_,_,_,_}=Imm, St) ->
+    {Imm,St#ost{t=undefined}};
+enc_opt({call_gen,N,K,F,L,As}, St) ->
+    {{call_gen,N,K,F,L,subst(As, St)},St#ost{t=t_any()}};
+enc_opt({'cond',Cs0}, St0) ->
+    case enc_opt_cs(Cs0, St0) of
+	[{'_',Imm,Type}] ->
+	    {Imm,St0#ost{t=Type}};
+	[{Cond,Imm,Type0}|Cs1] ->
+	    {Cs,Type} = enc_opt_cond_1(Cs1, Type0, [{Cond,Imm}]),
+	    {{'cond',Cs},St0#ost{t=Type}}
+    end;
+enc_opt({cons,H0,T0}, St0) ->
+    {H,#ost{t=TypeH}=St1} = enc_opt(H0, St0),
+    {T,#ost{t=TypeT}=St} = enc_opt(T0, St1),
+    {{cons,H,T},St#ost{t=t_cons(TypeH, TypeT)}};
+enc_opt({error,_}=Imm, St) ->
+    {Imm,St#ost{t=t_any()}};
+enc_opt({integer,V}, St) ->
+    {{integer,subst(V, St)},St#ost{t=t_integer()}};
+enc_opt({lc,E0,B,C}, St) ->
+    {E,_} = enc_opt(E0, St),
+    {{lc,E,B,C},St#ost{t=t_any()}};
+enc_opt({lc,E0,B,C,Dst}, St) ->
+    {E,_} = enc_opt(E0, St),
+    {{lc,E,B,C,Dst},St#ost{t=undefined}};
+enc_opt({list,Imm0,Dst}, St0) ->
+    {Imm,#ost{t=Type}=St1} = enc_opt(Imm0, St0),
+    St = set_type(Dst, Type, St1),
+    {{list,Imm,Dst},St#ost{t=undefined}};
+enc_opt(nil, St) ->
+    {nil,St#ost{t=t_nil()}};
+enc_opt({seq,H0,T0}, St0) ->
+    {H,St1} = enc_opt(H0, St0),
+    {T,St} = enc_opt(T0, St1),
+    {enc_opt_seq(H, T),St};
+enc_opt({set,_,_}=Imm, St) ->
+    {Imm,St#ost{t=undefined}};
+enc_opt({sub,Src0,Int,Dst}, St0) ->
+    Src = subst(Src0, St0),
+    Type = get_type(Src, St0),
+    St = case t_range(Type) of
+	     any ->
+		 propagate(Dst,
+			   fun(T, S) ->
+				   set_type(Src, t_add(T, Int), S)
+			   end,
+			   St0);
+	     {Lb,Ub} ->
+		 set_type(Dst, t_integer({Lb-Int,Ub-Int}), St0)
+	 end,
+    {{sub,Src,Int,Dst},St#ost{t=undefined}};
+enc_opt({'try',Try0,{P,Succ0},Else0,Dst}, St0) ->
+    {Try,_} = enc_opt(Try0, St0),
+    {Succ,_} = enc_opt(Succ0, St0),
+    {Else,_} = enc_opt(Else0, St0),
+    {{'try',Try,{P,Succ},Else,Dst},St0#ost{t=undefined}};
+enc_opt({var,_}=Imm, St) ->
+    Type = get_type(Imm, St),
+    {subst(Imm, St),St#ost{t=Type}}.
+
+remove_trailing_align({block,Bl}) ->
+    {block,remove_trailing_align(Bl)};
+remove_trailing_align({cons,H,{cons,align,nil}}) ->
+    H;
+remove_trailing_align({seq,H,T}) ->
+    {seq,H,remove_trailing_align(T)};
+remove_trailing_align(Imm) -> Imm.
+
+enc_opt_seq(none, T) ->
+    T;
+enc_opt_seq({list,Imm,Data}, {seq,{call,per,complete,[Data],_},_}=T) ->
+    %% Get rid of any explicit 'align' added by per_enc_open_type/2.
+    {seq,{list,remove_trailing_align(Imm),Data},T};
+enc_opt_seq({call,_,_,_,{var,_}=Dst}=H, T) ->
+    case is_var_unused(Dst, T) of
+	false -> {seq,H,T};
+	true -> T
+    end;
+enc_opt_seq(H, T) ->
+    {seq,H,T}.
+
+is_var_unused(_, align) ->
+    true;
+is_var_unused(V, {call,_,_,Args}) ->
+    not lists:member(V, Args);
+is_var_unused(V, {cons,H,T}) ->
+    is_var_unused(V, H) andalso is_var_unused(V, T);
+is_var_unused(_, _) ->
+    false.
+
+bit_size_propagate(Bin, Type, St) ->
+    case t_range(Type) of
+	any ->
+	    St;
+	{Lb,Ub} ->
+	    set_type(Bin, t_bitstring({Lb,Ub}), St)
+    end.
+
+byte_size_propagate(Bin, Type, St) ->
+    case t_range(Type) of
+	any ->
+	    St;
+	{Lb,Ub} ->
+	    set_type(Bin, t_binary({Lb*8,Ub*8}), St)
+    end.
+
+char_propagate(Dst, T, NumBits, St) ->
+    case t_range(T) of
+	any ->
+	    St;
+	{Sz,Sz} when Sz*NumBits rem 8 =:= 0 ->
+	    Bits = Sz*NumBits,
+	    set_type(Dst, t_binary({Bits,Bits}), St);
+	{Lb,Ub} ->
+	    Range = {Lb*NumBits,Ub*NumBits},
+	    case NumBits rem 8 of
+		0 ->
+		    set_type(Dst, t_binary(Range), St);
+		_ ->
+		    set_type(Dst, t_bitstring(Range), St)
+	    end
+    end.
+
+length_propagate(List, Type, St) ->
+    set_type(List, t_list(t_range(Type)), St).
+
+enc_opt_cond_1([{Cond,{error,_}=Imm,_}|T], St, Acc) ->
+    enc_opt_cond_1(T, St, [{Cond,Imm}|Acc]);
+enc_opt_cond_1([{Cond,Imm,Curr0}|T], Curr1, Acc) ->
+    Curr = t_join(Curr0, Curr1),
+    enc_opt_cond_1(T, Curr, [{Cond,Imm}|Acc]);
+enc_opt_cond_1([], St, Acc) ->
+    {lists:reverse(Acc),St}.
+
+enc_opt_cs([{Cond,Imm0}|T], St0) ->
+    case eo_eval_cond(Cond, St0) of
+	false ->
+	    enc_opt_cs(T, St0);
+	true ->
+	    {Imm,#ost{t=Type}} = enc_opt(Imm0, St0),
+	    [{'_',Imm,Type}];
+	maybe ->
+	    St = update_type_info(Cond, St0),
+	    {Imm,#ost{t=Type}} = enc_opt(Imm0, St),
+	    [{Cond,Imm,Type}|enc_opt_cs(T, St0)]
+    end;
+enc_opt_cs([], _) -> [].
+
+eo_eval_cond('_', _) ->
+    true;
+eo_eval_cond({Op,{var,_}=Var,Val}, St) ->
+    Type = get_type(Var, St),
+    case t_range(Type) of
+	any -> maybe;
+	{_,_}=Range -> eval_cond_range(Op, Range, Val)
+    end;
+eo_eval_cond({_Op,{expr,_},_Val}, _St) -> maybe.
+
+eval_cond_range(lt, {Lb,Ub}, Val) ->
+    if
+	Ub < Val -> true;
+	Val =< Lb -> false;
+	true -> maybe
+    end;
+eval_cond_range(_Op, _Range, _Val) -> maybe.
+
+update_type_info({ult,{var,_}=Var,Val}, St) ->
+    Int = t_integer({0,Val-1}),
+    Type = t_meet(get_type(Var, St), Int),
+    set_type(Var, Type, St);
+update_type_info({lt,{var,_}=Var,Val}, St) ->
+    Int = t_integer({0,Val-1}),
+    Type = t_meet(get_type(Var, St), Int),
+    set_type(Var, Type, St);
+update_type_info({eq,{var,_}=Var,Val}, St) when is_integer(Val) ->
+    Int = t_integer(Val),
+    Type = t_meet(get_type(Var, St), Int),
+    set_type(Var, Type, St);
+update_type_info({eq,_,_}, St) ->
+    St;
+update_type_info({ge,_,_}, St) -> St.
+
+subst_list(As, St) ->
+    [subst(A, St) || A <- As].
+
+subst({var,_}=Var, St) ->
+    Type = get_type(Var, St),
+    case t_type(Type) of
+	integer ->
+	    case t_range(Type) of
+		any -> Var;
+		{Val,Val} -> Val;
+		{_,_} -> Var
+	    end;
+	_ ->
+	    Var
+    end;
+subst(V, _St) -> V.
+
+set_type({var,Var}, {_,_}=Type, #ost{sym=Sym0}=St0) ->
+    Sym1 = gb_trees:enter(Var, Type, Sym0),
+    case gb_trees:lookup({propagate,Var}, Sym1) of
+	none ->
+	    St0#ost{sym=Sym1};
+	{value,Propagate} ->
+	    Sym = gb_trees:delete({propagate,Var}, Sym1),
+	    St = St0#ost{sym=Sym},
+	    Propagate(Type, St)
+    end.
+
+get_type({var,V}, #ost{sym=Sym}) ->
+    case gb_trees:lookup(V, Sym) of
+	none -> t_any();
+	{value,T} -> T
+    end.
+
+propagate({var,Var}, Propagate, #ost{sym=Sym0}=St) when is_function(Propagate, 2) ->
+    Sym = gb_trees:enter({propagate,Var}, Propagate, Sym0),
+    St#ost{sym=Sym}.
+
+%%%
+%%% A simple type system.
+%%%
+%%% Each type descriptions is a tuple {Type,Range}.
+%%% Type is one of the following atoms:
+%%%
+%%% Type name   Description
+%%% ---------   -----------
+%%% any         Anything.
+%%%
+%%% align       Basically iodata, but the list may contain bitstrings
+%%%             and the the atom 'align'. Can be passed to complete/1
+%%%             to construct a binary. Only used for aligned PER (per).
+%%%
+%%% bitstring   An Erlang bitstring.
+%%%
+%%% bitlist     A list that may be passed to list_to_bitstring/1 to
+%%%             construct a bitstring.
+%%%             NOTE: When analysing aligned PER (per), the number
+%%%             of bits in the bitlist is always divisible by 8 (if
+%%%             not, the type will be 'align' instead).
+%%%
+%%% binary      An Erlang binary (the number of bits is divisible by 8).
+%%%
+%%% iolist      An Erlang iolist.
+%%%
+%%% nil         []
+%%%
+%%% integer     An integer.
+%%%
+%%%
+%%% Range is one of:
+%%%
+%%%     any
+%%%     {LowerBound,UpperBound}
+%%%
+%%%
+
+t_align(Range) ->
+    {align,t__range(Range)}.
+
+t_any() ->
+    {any,any}.
+
+t_binary() ->
+    {binary,any}.
+
+t_binary(Range) ->
+    {binary,t__range(Range)}.
+
+t_bitlist() ->
+    {bitlist,any}.
+
+t_bitstring() ->
+    {bitstring,any}.
+
+t_bitstring(Range0) ->
+    case t__range(Range0) of
+	{Bits,Bits}=Range when Bits rem 8 =:= 0 ->
+	    {binary,Range};
+	Range ->
+	    {bitstring,Range}
+    end.
+
+t_add({integer,{Lb,Ub}}, N) ->
+    {integer,{Lb+N,Ub+N}}.
+
+t_cons({_,_}=T1, {_,_}=T2) ->
+    T = case {t__cons_type(T1),t__cons_type(T2)} of
+	    {_,any} -> any;
+	    {any,_} -> any;
+	    {align,_} -> align;
+	    {_,align} -> align;
+	    {binary,binary} -> iolist;
+	    {binary,bitstring} -> bitlist;
+	    {bitstring,binary} -> bitlist;
+	    {bitstring,bitstring} -> bitlist
+	end,
+    {T,t__cons_ranges(t__cons_range(T1), t__cons_range(T2))}.
+
+t_integer() ->
+    {integer,any}.
+
+t_integer(Range) ->
+    {integer,t__range(Range)}.
+
+t_iolist() ->
+    {iolist,any}.
+
+t_list(Range) ->
+    {list,t__range(Range)}.
+
+t_nil() ->
+    {nil,{0,0}}.
+
+t_meet({T1,Range1}, {T2,Range2}) ->
+    {t_meet_types(T1, T2),t_meet_ranges(Range1, Range2)}.
+
+t_meet_types(integer, integer) -> integer;
+t_meet_types(any, integer) -> integer.
+
+t_meet_ranges(any, Range) ->
+    Range;
+t_meet_ranges({Lb1,Ub1}, {Lb2,Ub2}) ->
+    if
+	Lb1 =< Ub2, Lb2 =< Ub1 ->
+	    {max(Lb1, Lb2),Ub1};
+	Lb2 =< Ub1, Lb1 =< Ub2 ->
+	    {max(Lb1, Lb2),Ub2}
+    end.
+
+t_join({T1,Range1}, {T2,Range2}) ->
+    T = t_join_types(lists:sort([T1,T2])),
+    Range = t_join_ranges(Range1, Range2),
+    {T,Range}.
+
+t_join_ranges({Lb1,Ub1}, {Lb2,Ub2}) ->
+    {min(Lb1, Lb2),max(Ub1, Ub2)};
+t_join_ranges(any, _) -> any;
+t_join_ranges(_, any) -> any.
+
+t_join_types([T,T]) -> T;
+t_join_types([align,any]) -> any;
+t_join_types([align,_]) -> align;
+t_join_types([any,_]) -> any;
+t_join_types([bitlist,bitstring]) -> any;
+t_join_types([bitlist,integer]) -> any;
+t_join_types([bitlist,iolist]) -> bitlist;
+t_join_types([bitlist,nil]) -> bitlist;
+t_join_types([binary,bitlist]) -> bitlist;
+t_join_types([binary,bitstring]) -> bitstring;
+t_join_types([binary,integer]) -> binary;
+t_join_types([binary,iolist]) -> iolist;
+t_join_types([binary,nil]) -> iolist;
+t_join_types([bitstring,integer]) -> any;
+t_join_types([bitstring,iolist]) -> any;
+t_join_types([bitstring,nil]) -> any;
+t_join_types([integer,_]) -> any;
+t_join_types([iolist,nil]) -> iolist.
+
+t_type({T,_}) -> T.
+
+t_range({_,Range}) -> Range.
+
+t__cons_type({align,_}) -> align;
+t__cons_type({any,_}) -> any;
+t__cons_type({binary,_}) -> binary;
+t__cons_type({bitstring,_}) -> bitstring;
+t__cons_type({bitlist,_}) -> bitstring;
+t__cons_type({integer,_}) -> binary;
+t__cons_type({iolist,_}) -> binary;
+t__cons_type({nil,_}) -> binary.
+
+t__cons_range({integer,_}) -> {8,8};
+t__cons_range({_,Range}) -> Range.
+
+t__cons_ranges({Lb1,Ub1}, {Lb2,Ub2}) ->
+    {Lb1+Lb2,Ub1+Ub2};
+t__cons_ranges(any, _) -> any;
+t__cons_ranges(_, any) -> any.
+
+t__range({Lb,Ub}=Range) when is_integer(Lb), is_integer(Ub) ->
+    Range;
+t__range(any) ->
+    any;
+t__range(Val) when is_integer(Val) ->
+    {Val,Val}.
+
+
+%%%
+%%% Code generation for encoding.
+%%%
+
+enc_cg({cons,_,_}=Cons) ->
+    enc_cg_cons(Cons);
+enc_cg({block,Imm}) ->
+    emit(["begin",nl]),
+    enc_cg(Imm),
+    emit([nl,
+	  "end"]);
+enc_cg({seq,First,Then}) ->
+    enc_cg(First),
+    emit([com,nl]),
+    enc_cg(Then);
+enc_cg(align) ->
+    emit(align);
+enc_cg({apply,F0,As0}) ->
+    As = enc_call_args(As0, ""),
+    case F0 of
+	{local,F,_} when is_atom(F) ->
+	    emit([{asis,F},"(",As,")"]);
+	{M,F,_} ->
+	    emit([{asis,M},":",{asis,F},"(",As,")"])
+    end;
+enc_cg({assign,Dst0,Expr}) ->
+    Dst = mk_val(Dst0),
+    emit([Dst," = ",Expr]);
+enc_cg({binary,PutBits}) ->
+    emit(["<<",enc_cg_put_bits(PutBits, ""),">>"]);
+enc_cg({call,M,F,As0}) ->
+    As = [mk_val(A) || A <- As0],
+    asn1ct_func:call(M, F, As);
+enc_cg({call,M,F,As0,Dst}) ->
+    As = [mk_val(A) || A <- As0],
+    emit([mk_val(Dst)," = "]),
+    asn1ct_func:call(M, F, As);
+enc_cg({call_gen,Prefix,Key,Gen,_,As0}) ->
+    As = [mk_val(A) || A <- As0],
+    asn1ct_func:call_gen(Prefix, Key, Gen, As);
+enc_cg({'cond',Cs}) ->
+    enc_cg_cond(Cs);
+enc_cg({error,Error}) when is_function(Error, 0) ->
+    Error();
+enc_cg({error,Var0}) ->
+    Var = mk_val(Var0),
+    emit(["exit({error,{asn1,{illegal_value,",Var,"}}})"]);
+enc_cg({integer,Int}) ->
+    emit(mk_val(Int));
+enc_cg({lc,Body,Var,List}) ->
+    emit("["),
+    enc_cg(Body),
+    emit([" || ",mk_val(Var)," <- ",mk_val(List),"]"]);
+enc_cg({lc,Body,Var,List,Dst}) ->
+    emit([mk_val(Dst)," = ["]),
+    enc_cg(Body),
+    emit([" || ",mk_val(Var)," <- ",mk_val(List),"]"]);
+enc_cg({list,List,Dst}) ->
+    emit([mk_val(Dst)," = "]),
+    enc_cg(List);
+enc_cg(nil) ->
+    emit("[]");
+enc_cg({sub,Src0,Int,Dst0}) ->
+    Src = mk_val(Src0),
+    Dst = mk_val(Dst0),
+    emit([Dst," = ",Src," - ",Int]);
+enc_cg({set,{var,Src},{var,Dst}}) ->
+    emit([Dst," = ",Src]);
+enc_cg({'try',Try,{P,Succ},Else,Dst}) ->
+    emit([mk_val(Dst)," = try "]),
+    enc_cg(Try),
+    emit([" of",nl,
+	  mk_val(P)," ->",nl]),
+    enc_cg(Succ),
+    emit([nl,
+	  "catch throw:invalid ->",nl]),
+    enc_cg(Else),
+    emit([nl,
+	  "end"]);
+enc_cg({var,V}) ->
+    emit(V).
+
+enc_cg_cons(Cons) ->
+    emit("["),
+    enc_cg_cons_1(Cons),
+    emit("]").
+
+enc_cg_cons_1({cons,H,{cons,_,_}=T}) ->
+    enc_cg(H),
+    emit([com,nl]),
+    enc_cg_cons_1(T);
+enc_cg_cons_1({cons,H,nil}) ->
+    enc_cg(H);
+enc_cg_cons_1({cons,H,T}) ->
+    enc_cg(H),
+    emit("|"),
+    enc_cg(T).
+
+enc_call_args([A|As], Sep) ->
+    [Sep,mk_val(A)|enc_call_args(As, ", ")];
+enc_call_args([], _) -> [].
+
+enc_cg_cond(Cs) ->
+    emit("if "),
+    enc_cg_cond(Cs, ""),
+    emit([nl,
+	  "end"]).
+
+enc_cg_cond([C|Cs], Sep) ->
+    emit(Sep),
+    enc_cg_cond_1(C),
+    enc_cg_cond(Cs, [";",nl]);
+enc_cg_cond([], _) -> ok.
+
+enc_cg_cond_1({Cond,Action}) ->
+    enc_cond_term(Cond),
+    emit([" ->",nl]),
+    enc_cg(Action).
+
+enc_cond_term('_') ->
+    emit("true");
+enc_cond_term({ult,Var0,Int}) ->
+    Var = mk_val(Var0),
+    N = uper_num_bits(Int),
+    case 1 bsl N of
+	Int ->
+	    emit([Var," bsr ",N," =:= 0"]);
+	_ ->
+	    emit(["0 =< ",Var,", ",Var," < ",Int])
+    end;
+enc_cond_term({eq,Var0,Term}) ->
+    Var = mk_val(Var0),
+    emit([Var," =:= ",{asis,Term}]);
+enc_cond_term({ge,Var0,Int}) ->
+    Var = mk_val(Var0),
+    emit([Var," >= ",Int]);
+enc_cond_term({lt,Var0,Int}) ->
+    Var = mk_val(Var0),
+    emit([Var," < ",Int]).
+
+enc_cg_put_bits([{put_bits,Val0,N,[1]}|T], Sep) ->
+    Val = mk_val(Val0),
+    [[Sep,Val,":",integer_to_list(N)]|enc_cg_put_bits(T, ",")];
+enc_cg_put_bits([], _) -> [].
+
+mk_val({var,Str}) -> Str;
+mk_val({expr,Str}) -> Str;
+mk_val(Int) when is_integer(Int) -> integer_to_list(Int);
+mk_val(Other) -> {asis,Other}.
+
+%%%
+%%% Generate a function that maps a name of a bit position
+%%%  to the bit position.
+%%%
+
+bit_string_name2pos_fun(NNL, Src) ->
+    {call_gen,"bit_string_name2pos_",NNL,
+     fun(Fd, Name) -> gen_name2pos(Fd, Name, NNL) end,[],[Src]}.
+
+gen_name2pos(Fd, Name, Names) ->
+    Cs0 = gen_name2pos_cs(Names, Name),
+    Cs = Cs0 ++ [bit_clause(Name),nil_clause(),invalid_clause()],
+    F0 = {function,1,Name,1,Cs},
+    F = erl_parse:new_anno(F0),
+    file:write(Fd, [erl_pp:function(F)]).
+
+gen_name2pos_cs([{K,V}|T], Name) ->
+    P = [{cons,0,{atom,0,K},{var,0,'T'}}],
+    B = [{cons,0,{integer,0,V},{call,0,{atom,0,Name},[{var,0,'T'}]}}],
+    [{clause,0,P,[],B}|gen_name2pos_cs(T, Name)];
+gen_name2pos_cs([], _) -> [].
+
+bit_clause(Name) ->
+    VarT = {var,0,'T'},
+    VarPos = {var,0,'Pos'},
+    P = [{cons,0,{tuple,0,[{atom,0,bit},VarPos]},VarT}],
+    G = [[{call,0,{atom,0,is_integer},[VarPos]}]],
+    B = [{cons,0,VarPos,{call,0,{atom,0,Name},[VarT]}}],
+    {clause,0,P,G,B}.
+
+nil_clause() ->
+    P = B = [{nil,0}],
+    {clause,0,P,[],B}.
+
+invalid_clause() ->
+    P = [{var,0,'_'}],
+    B = [{call,0,{atom,0,throw},[{atom,0,invalid}]}],
+    {clause,0,P,[],B}.
+
+%%%
+%%% Hoist alignment to reduce the number of list elements in
+%%% encode. Fewer lists elements means faster traversal in
+%%% complete/{2,3}.
+%%%
+%%% For example, the following data sequence:
+%%%
+%%%   [align,<<1:1,0:1>>,[align,<<Len:16>>|Data]]
+%%%
+%%% can be rewritten to:
+%%%
+%%%   [align,<<1:1,0:1,0:6>>,[<<Len:16>>|Data]]
+%%%
+%%% The change from the literal <<1:1,0:1>> to <<1:1,0:1,0:6>>
+%%% comes for free, and we have eliminated one element of the
+%%% sub list.
+%%%
+%%% We must be careful not to rewrite:
+%%%
+%%%   [<<1:1,0:1>>,[align,<<Len:16>>|Data]]
+%%%
+%%% to:
+%%%
+%%%   [[<<1:1,0:1>>,align],[<<Len:16>>|Data]]
+%%%
+%%% because even though [<<1:0,0:1>>,align] is a literal and does
+%%% not add any additional construction cost, there is one more
+%%% sub list that needs to be traversed.
+%%%
+
+enc_hoist_align(Imm0) ->
+    Imm = enc_hoist_align_reverse(Imm0, []),
+    enc_hoist_align(Imm, false, []).
+
+enc_hoist_align_reverse([H|T], Acc) ->
+    case enc_opt_al_1([H], 0) of
+	{[H],_} ->
+	    enc_hoist_align_reverse(T, [H|Acc]);
+	{_,_} ->
+	    lists:reverse(T, [H,stop|Acc])
+    end;
+enc_hoist_align_reverse([], Acc) -> Acc.
+
+enc_hoist_align([stop|T], _Aligned, Acc) ->
+    lists:reverse(T, Acc);
+enc_hoist_align([{block,Bl0}|T], Aligned, Acc) ->
+    Bl = case Aligned of
+	     false -> Bl0;
+	     true -> enc_hoist_block(Bl0)
+	 end,
+    case is_beginning_aligned(Bl) of
+	false ->
+	    enc_hoist_align(T, false, [{block,Bl}|Acc]);
+	true ->
+	    enc_hoist_align(T, true, [{put_bits,0,0,[1,align]},
+				      {block,Bl}|Acc])
+    end;
+enc_hoist_align([H|T], _, Acc) ->
+    enc_hoist_align(T, false, [H|Acc]);
+enc_hoist_align([], _, Acc) -> Acc.
+
+enc_hoist_block(Bl) ->
+    try
+	enc_hoist_block_1(lists:reverse(Bl))
+    catch
+	throw:impossible ->
+	    Bl
+    end.
+
+enc_hoist_block_1([{'cond',Cs0}|T]) ->
+    Cs = [[C|enc_hoist_block_2(Act)] || [C|Act] <- Cs0],
+    H = {'cond',Cs},
+    lists:reverse(T, [H]);
+enc_hoist_block_1(_) ->
+    throw(impossible).
+
+enc_hoist_block_2([{'cond',_}|_]=L) ->
+    enc_hoist_block(L);
+enc_hoist_block_2([{error,_}]=L) ->
+    L;
+enc_hoist_block_2([]) ->
+    [{put_bits,0,0,[1,align]}];
+enc_hoist_block_2(L) ->
+    case lists:last(L) of
+	{put_bits,_,_,_} ->
+	    L ++ [{put_bits,0,0,[1,align]}];
+	_ ->
+	    throw(impossible)
+    end.
+
+%%%
+%%% Optimize alignment for encoding.
+%%%
+
+enc_opt_al(Imm0) ->
+    {Imm,_} = enc_opt_al_1(Imm0, unknown),
+    Imm.
+
+enc_opt_al_1([H0|T0], Al0) ->
+    {H,Al1} = enc_opt_al(H0, Al0),
+    {T,Al} = enc_opt_al_1(T0, Al1),
+    {H++T,Al};
+enc_opt_al_1([], Al) -> {[],Al}.
+
+enc_opt_al({assign,_,_}=Imm, Al) ->
+    {[Imm],Al};
+enc_opt_al({block,Bl0}, Al0) ->
+    {Bl,Al} = enc_opt_al_1(Bl0, Al0),
+    {[{block,Bl}],Al};
+enc_opt_al({call,erlang,iolist_to_binary,[_]}=Imm, Al) ->
+    {[Imm],Al};
+enc_opt_al({call,per_common,encode_fragmented,[_,U]}=Call, Al) ->
+    case U rem 8 of
+	0 -> {[Call],Al};
+	_ -> {[Call],unknown}
+    end;
+enc_opt_al({call,per_common,encode_unconstrained_number,[_]}=Call, _) ->
+    {[Call],0};
+enc_opt_al({call,_,_,_,_}=Call, Al) ->
+    {[Call],Al};
+enc_opt_al({'cond',Cs0}, Al0) ->
+    {Cs,Al} = enc_opt_al_cond(Cs0, Al0),
+    {[{'cond',Cs}],Al};
+enc_opt_al({error,_}=Imm, Al) ->
+    {[Imm],Al};
+enc_opt_al({list,Imm0,Dst}, Al) ->
+    Imm1 = enc_opt_hoist_align(Imm0),
+    {Imm,_} = enc_opt_al_1(Imm1, 0),
+    {[{list,Imm,Dst}],Al};
+enc_opt_al({put_bits,V,N,[U,align]}, Al0) when Al0 rem 8 =:= 0 ->
+    Al = if
+	     is_integer(N) -> N*U;
+	     N =:= binary, U rem 8 =:= 0 -> 0;
+	     true -> unknown
+	 end,
+    {[{put_bits,V,N,[U]}],Al};
+enc_opt_al({put_bits,V,binary,[U,align]}, Al0) when is_integer(Al0) ->
+    N = 8 - (Al0 rem 8),
+    Al = case U rem 8 of
+	     0 -> 0;
+	     _ -> unknown
+	 end,
+    {[{put_bits,0,N,[1]},{put_bits,V,binary,[U]}],Al};
+enc_opt_al({put_bits,V,N0,[U,align]}, Al0) when is_integer(N0), is_integer(Al0) ->
+    N = N0 + (8 - Al0 rem 8),
+    Al = N0*U,
+    {[{put_bits,V,N,[1]}],Al};
+enc_opt_al({put_bits,_,N,[U,align]}=PutBits, _) when is_integer(N) ->
+    {[PutBits],N*U};
+enc_opt_al({put_bits,_,binary,[U,align]}=PutBits, _) when U rem 8 =:= 0 ->
+    {[PutBits],0};
+enc_opt_al({put_bits,_,N,[U]}=PutBits, Al) when is_integer(N), is_integer(Al) ->
+    {[PutBits],Al+N*U};
+enc_opt_al({put_bits,_,binary,[U]}=PutBits, Al) when U rem 8 =:= 0 ->
+    {[PutBits],Al};
+enc_opt_al({set,_,_}=Imm, Al) ->
+    {[Imm],Al};
+enc_opt_al({sub,_,_,_}=Imm, Al) ->
+    {[Imm],Al};
+enc_opt_al({'try',_,_,_,_}=Imm, Al) ->
+    {[Imm],Al};
+enc_opt_al(Imm, _) ->
+    {[Imm],unknown}.
+
+enc_opt_al_cond(Cs0, Al0) ->
+    enc_opt_al_cond_1(Cs0, Al0, [], []).
+
+enc_opt_al_cond_1([['_',{error,_}]=C|Cs], Al, CAcc, AAcc) ->
+    enc_opt_al_cond_1(Cs, Al, [C|CAcc], AAcc);
+enc_opt_al_cond_1([[C|Act0]|Cs0], Al0, CAcc, AAcc) ->
+    {Act,Al1} = enc_opt_al_1(Act0, Al0),
+    Al = if
+	     Al1 =:= unknown -> Al1;
+	     true -> Al1 rem 8
+	 end,
+    enc_opt_al_cond_1(Cs0, Al0, [[C|Act]|CAcc], [Al|AAcc]);
+enc_opt_al_cond_1([], _, CAcc, AAcc) ->
+    Al = case lists:usort(AAcc) of
+	     [] -> unknown;
+	     [Al0] -> Al0;
+	     [_|_] -> unknown
+	 end,
+    {lists:reverse(CAcc),Al}.
+
+enc_opt_hoist_align([{'cond',Cs0},{put_bits,0,0,[1,align]}]=Imm) ->
+    try
+	Cs = [insert_align_last(C) || C <- Cs0],
+	[{'cond',Cs}]
+    catch
+	throw:impossible ->
+	    Imm
+    end;
+enc_opt_hoist_align(Imm) -> Imm.
+
+insert_align_last([_,{error,_}]=C) ->
+    C;
+insert_align_last([H|T]) ->
+    case lists:last(T) of
+	{put_bits,_,_,_} ->
+	    [H|T ++ [{put_bits,0,0,[1,align]}]];
+	_ ->
+	    throw(impossible)
+    end.
+
+%%%
+%%% For the aligned PER format, fix up the intermediate format
+%%% before code generation. Code generation will be somewhat
+%%% easier if 'align' appear as a separate instruction.
+%%%
+
+per_fixup([{apply,_,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([{block,Block}|T]) ->
+    [{block,per_fixup(Block)}|per_fixup(T)];
+per_fixup([{'assign',_,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([{'cond',Cs0}|T]) ->
+    Cs = [[C|per_fixup(Act)] || [C|Act] <- Cs0],
+    [{'cond',Cs}|per_fixup(T)];
+per_fixup([{call,_,_,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([{call,_,_,_,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([{call_gen,_,_,_,_,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([{error,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([{lc,B,V,L}|T]) ->
+    [{lc,per_fixup(B),V,L}|per_fixup(T)];
+per_fixup([{lc,B,V,L,Dst}|T]) ->
+    [{lc,per_fixup(B),V,L,Dst}|per_fixup(T)];
+per_fixup([{list,Imm,Dst}|T]) ->
+    [{list,per_fixup(Imm),Dst}|per_fixup(T)];
+per_fixup([{set,_,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([{sub,_,_,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([{'try',Try0,{P,Succ0},Else0,Dst}|T]) ->
+    Try = per_fixup(Try0),
+    Succ = per_fixup(Succ0),
+    Else = per_fixup(Else0),
+    [{'try',Try,{P,Succ},Else,Dst}|per_fixup(T)];
+per_fixup([{put_bits,_,_,_}|_]=L) ->
+    fixup_put_bits(L);
+per_fixup([{var,_}=H|T]) ->
+    [H|per_fixup(T)];
+per_fixup([]) -> [].
+
+fixup_put_bits([{put_bits,0,0,[_,align]}|T]) ->
+    [align|fixup_put_bits(T)];
+fixup_put_bits([{put_bits,0,0,_}|T]) ->
+    fixup_put_bits(T);
+fixup_put_bits([{put_bits,V,N,[U,align]}|T]) ->
+    [align,{put_bits,V,N,[U]}|fixup_put_bits(T)];
+fixup_put_bits([{put_bits,_,_,_}=H|T]) ->
+    [H|fixup_put_bits(T)];
+fixup_put_bits(Other) -> per_fixup(Other).
+
 %% effective_constraint(Type,C)
 %% Type = atom()
 %% C = [C1,...]
@@ -705,8 +2741,10 @@ mk_dest(S) -> S.
 %% returns a value range that has the lower bound set to the lowest value
 %% of all single values and lower bound values in C and the upper bound to
 %% the greatest value.
-effective_constraint(integer,[C={{_,_},_}|_Rest]) -> % extension
-    [C];
+effective_constraint(integer, [{{_,_}=Root,_}|_Rest]) ->
+    %% Normalize extension. Note that any range given for the
+    %% extension should be ignored anyway.
+    [{Root,[]}];
 effective_constraint(integer, C) ->
     SVs = get_constraints(C, 'SingleValue'),
     SV = effective_constr('SingleValue', SVs),
diff --git a/lib/asn1/src/asn1ct_name.erl b/lib/asn1/src/asn1ct_name.erl
index ba52e66ce3..72d541cbbc 100644
--- a/lib/asn1/src/asn1ct_name.erl
+++ b/lib/asn1/src/asn1ct_name.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %% 
 %% %CopyrightEnd%
 %%
diff --git a/lib/asn1/src/asn1ct_parser.yrl b/lib/asn1/src/asn1ct_parser.yrl
deleted file mode 100644
index 083162f191..0000000000
--- a/lib/asn1/src/asn1ct_parser.yrl
+++ /dev/null
@@ -1,1177 +0,0 @@
-%%<copyright>
-%% <year>1997-2008</year>
-%% <holder>Ericsson AB, All Rights Reserved</holder>
-%%</copyright>
-%%<legalnotice>
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% The Initial Developer of the Original Code is Ericsson AB.
-%%</legalnotice>

-%%

-Nonterminals

-ModuleDefinition ModuleIdentifier DefinitiveIdentifier DefinitiveObjIdComponentList

-DefinitiveObjIdComponent TagDefault ExtensionDefault 

-ModuleBody Exports SymbolsExported Imports SymbolsImported

-SymbolsFromModuleList SymbolsFromModule GlobalModuleReference AssignedIdentifier SymbolList

-Symbol Reference AssignmentList Assignment 

-ExtensionAndException

-ComponentTypeLists

-Externaltypereference Externalvaluereference DefinedType DefinedValue 

-AbsoluteReference ItemSpec ItemId ComponentId TypeAssignment

-ValueAssignment 

-% ValueSetTypeAssignment 

-ValueSet 

-Type BuiltinType NamedType ReferencedType

-Value ValueNotNull BuiltinValue ReferencedValue NamedValue 

-% BooleanType

-BooleanValue IntegerType NamedNumberList NamedNumber SignedNumber 

-% inlined IntegerValue 

-EnumeratedType

-% inlined Enumerations 

-Enumeration EnumerationItem 

-% inlined EnumeratedValue

-% RealType

-RealValue NumericRealValue SpecialRealValue BitStringType 

-% inlined BitStringValue

-IdentifierList 

-% OctetStringType 

-% inlined OctetStringValue 

-% NullType NullValue

-SequenceType ComponentTypeList ComponentType 

-% SequenceValue SequenceOfValue

-ComponentValueList SequenceOfType

-SAndSOfValue ValueList SetType 

-% SetValue SetOfValue 

-SetOfType 

-ChoiceType 

-% AlternativeTypeList made common with ComponentTypeList

-ChoiceValue

-AnyValue

-AnyDefBy

-SelectionType 

-TaggedType Tag ClassNumber Class 

-% redundant TaggedValue

-% EmbeddedPDVType EmbeddedPDVValue ExternalType ExternalValue ObjectIdentifierType

-ObjectIdentifierValue ObjIdComponentList ObjIdComponent 

-% NameForm NumberForm NameAndNumberForm 

-CharacterStringType

-RestrictedCharacterStringValue CharacterStringList 

-% CharSyms CharsDefn 

-Quadruple

-% Group Plane Row Cell

-Tuple

-% TableColumn TableRow

-% UnrestrictedCharacterString

-CharacterStringValue 

-% UnrestrictedCharacterStringValue

-ConstrainedType Constraint ConstraintSpec TypeWithConstraint

-ElementSetSpecs ElementSetSpec 

-%GeneralConstraint

-UserDefinedConstraint UserDefinedConstraintParameter 

-UserDefinedConstraintParameters

-ExceptionSpec

-ExceptionIdentification

-Unions

-UnionMark

-UElems

-Intersections

-IntersectionElements

-IntersectionMark

-IElems

-Elements

-Elems

-SubTypeElements

-Exclusions

-LowerEndpoint

-UpperEndpoint

-LowerEndValue

-UpperEndValue

-TypeConstraints NamedConstraint PresenceConstraint

-

-ParameterizedTypeAssignment

-ParameterList

-Parameters

-Parameter

-ParameterizedType

-

-% X.681

-ObjectClassAssignment ObjectClass ObjectClassDefn 

-FieldSpecs FieldSpec OptionalitySpec WithSyntaxSpec

-TokenOrGroupSpecs TokenOrGroupSpec

-SyntaxList OptionalGroup RequiredToken Word

-TypeOptionalitySpec

-ValueOrObjectOptSpec

-VSetOrOSetOptSpec

-ValueOptionalitySpec

-ObjectOptionalitySpec

-ValueSetOptionalitySpec

-ObjectSetOptionalitySpec

-% X.681 chapter 15

-InformationFromObjects

-ValueFromObject

-%ValueSetFromObjects

-TypeFromObject

-%ObjectFromObject

-%ObjectSetFromObjects

-ReferencedObjects

-FieldName

-PrimitiveFieldName

-

-ObjectAssignment

-ObjectSetAssignment

-ObjectSet

-ObjectSetElements

-Object

-ObjectDefn

-DefaultSyntax

-DefinedSyntax

-FieldSettings

-FieldSetting

-DefinedSyntaxTokens

-DefinedSyntaxToken

-Setting

-DefinedObject

-ObjectFromObject

-ObjectSetFromObjects

-ParameterizedObject

-ExternalObjectReference

-DefinedObjectSet

-DefinedObjectClass

-ExternalObjectClassReference

-

-% X.682

-TableConstraint

-ComponentRelationConstraint

-ComponentIdList

-

-% X.683

-ActualParameter

-.

-

-%UsefulType. 

-

-Terminals

-'ABSENT' 'ABSTRACT-SYNTAX' 'ALL' 'ANY'

-'APPLICATION' 'AUTOMATIC' 'BEGIN' 'BIT'

-'BOOLEAN' 'BY' 'CHARACTER' 'CHOICE' 'CLASS' 'COMPONENT'

-'COMPONENTS' 'CONSTRAINED' 'DEFAULT' 'DEFINED' 'DEFINITIONS'

-'EMBEDDED' 'END' 'ENUMERATED' 'EXCEPT' 'EXPLICIT'

-'EXPORTS' 'EXTENSIBILITY' 'EXTERNAL' 'FALSE' 'FROM' 'GeneralizedTime' 

-'TYPE-IDENTIFIER' 

-'IDENTIFIER' 'IMPLICIT' 'IMPLIED' 'IMPORTS'

-'INCLUDES' 'INSTANCE' 'INTEGER' 'INTERSECTION'

-'MAX' 'MIN' 'MINUS-INFINITY' 'NULL'

-'OBJECT' 'ObjectDescriptor' 'OCTET' 'OF' 'OPTIONAL' 'PDV' 'PLUS-INFINITY'

-'PRESENT' 'PRIVATE' 'REAL' 'SEQUENCE' 'SET' 'SIZE'

-'STRING' 'SYNTAX' 'TAGS' 'TRUE' 'UNION'

-'UNIQUE' 'UNIVERSAL' 'UTCTime' 'WITH'

-'{' '}' '(' ')' '.' '::=' ';' ',' '@' '*' '-' '[' ']'

-'!' '..' '...' '|' '<' ':' '^'

-number identifier typereference restrictedcharacterstringtype 

-bstring hstring cstring typefieldreference valuefieldreference

-objectclassreference word.

-

-Rootsymbol ModuleDefinition.

-Endsymbol '$end'.

-

-Left 300 'EXCEPT'.

-Left 200 '^'.

-Left 200 'INTERSECTION'.

-Left 100 '|'.

-Left 100 'UNION'.

-

-

-ModuleDefinition -> ModuleIdentifier

-	'DEFINITIONS'

-	TagDefault

-	ExtensionDefault

-	'::='

-	'BEGIN'

-	ModuleBody

-	'END' : 

-		{'ModuleBody',Ex,Im,Types} = '$7',

-		{{typereference,Pos,Name},Defid} = '$1',

-		#module{

-			pos= Pos,

-			name= Name,

-			defid= Defid,

-			tagdefault='$3',

-			extensiondefault='$4',

-			exports=Ex,

-			imports=Im,

-			typeorval=Types}.

-%	{module, '$1','$3','$6'}.

-% Results always in a record of type module defined in asn_records.hlr

-

-ModuleIdentifier -> typereference DefinitiveIdentifier : 

-	put(asn1_module,'$1'#typereference.val),

-	{'$1','$2'}.

-

-DefinitiveIdentifier -> '{' DefinitiveObjIdComponentList '}' : '$2' .

-DefinitiveIdentifier -> '$empty': [].

-

-DefinitiveObjIdComponentList -> DefinitiveObjIdComponent : ['$1'].

-DefinitiveObjIdComponentList -> DefinitiveObjIdComponent DefinitiveObjIdComponentList : ['$1'|'$2'].

-

-DefinitiveObjIdComponent -> identifier : '$1' . %expanded->

-% DefinitiveObjIdComponent -> NameForm : '$1' . 

-DefinitiveObjIdComponent -> number : '$1' . %expanded->

-% DefinitiveObjIdComponent -> DefinitiveNumberForm : 'fix' . 

-DefinitiveObjIdComponent -> identifier '(' number ')' : {'$1','$3'} . %expanded->

-% DefinitiveObjIdComponent -> DefinitiveNameAndNumberForm  : {'$1','$3'} .

-

-% DefinitiveNumberForm -> number : 'fix' .

- 

-% DefinitiveNameAndNumberForm -> identifier '(' DefinitiveNumberForm ')' : 'fix' .

- 

-TagDefault -> 'EXPLICIT' 'TAGS' : put(tagdefault,'EXPLICIT'),'EXPLICIT' .

-TagDefault -> 'IMPLICIT' 'TAGS' : put(tagdefault,'IMPLICIT'),'IMPLICIT' .

-TagDefault -> 'AUTOMATIC' 'TAGS' : put(tagdefault,'AUTOMATIC'),'AUTOMATIC' .

-TagDefault -> '$empty': put(tagdefault,'EXPLICIT'),'EXPLICIT'. % because this is the default

-

-ExtensionDefault -> 'EXTENSIBILITY' 'IMPLIED' : 'IMPLIED'.

-ExtensionDefault -> '$empty' : 'false'. % because this is the default

-

-ModuleBody -> Exports Imports AssignmentList : {'ModuleBody','$1','$2','$3'}.

-ModuleBody -> '$empty' : {'ModuleBody',nil,nil,[]}.

-

-Exports -> 'EXPORTS' SymbolList ';' : {exports,'$2'}.

-Exports -> 'EXPORTS'  ';' : {exports,[]}.

-Exports -> '$empty' : {exports,all} .

-

-% inlined above SymbolsExported -> SymbolList : '$1'.

-% inlined above SymbolsExported -> '$empty' : [].

-

-Imports -> 'IMPORTS' SymbolsFromModuleList ';' : {imports,'$2'}.

-Imports -> 'IMPORTS'  ';' : {imports,[]}.

-Imports -> '$empty' : {imports,[]} .

-

-% inlined above SymbolsImported -> SymbolsFromModuleList : '$1'.

-% inlined above SymbolsImported -> '$empty' : [].

-

-SymbolsFromModuleList -> SymbolsFromModule :['$1'].

-% SymbolsFromModuleList -> SymbolsFromModuleList SymbolsFromModule :$1.%changed

-SymbolsFromModuleList -> SymbolsFromModule SymbolsFromModuleList :['$1'|'$2'].

-

-% expanded SymbolsFromModule -> SymbolList 'FROM' GlobalModuleReference : #'SymbolsFromModule'{symbols = '$1',module='$3'}.

-SymbolsFromModule -> SymbolList 'FROM' typereference : #'SymbolsFromModule'{symbols = '$1',module='$3'}.

-SymbolsFromModule -> SymbolList 'FROM' typereference '{' ValueList '}': #'SymbolsFromModule'{symbols = '$1',module='$3'}.

-%SymbolsFromModule -> SymbolList 'FROM' typereference identifier: #'SymbolsFromModule'{symbols = '$1',module='$3'}.

-%SymbolsFromModule -> SymbolList 'FROM' typereference Externalvaluereference: #'SymbolsFromModule'{symbols = '$1',module='$3'}.

-%SymbolsFromModule -> SymbolList 'FROM' typereference DefinedValue: #'SymbolsFromModule'{symbols = '$1',module='$3'}.

-

-% inlined GlobalModuleReference -> typereference AssignedIdentifier : {'$1','$2'} .

-

-% inlined above AssignedIdentifier -> '{' ValueList '}' : '$2'.

-% replaced AssignedIdentifier -> '{' DefinedValue ObjIdComponentList '}' :{'$2','$3'}.

-% not necessary , replaced by SAndSOfValue AssignedIdentifier -> ObjectIdentifierValue :'$1'.

-% AssignedIdentifier -> DefinedValue : '$1'. 

-% inlined AssignedIdentifier -> '$empty' : undefined.

-

-SymbolList -> Symbol : ['$1'].

-SymbolList -> Symbol ',' SymbolList :['$1'|'$3'].

-

-Symbol -> Reference :'$1'.

-% later Symbol -> ParameterizedReference :'$1'.

-

-Reference -> typereference :'$1'.

-Reference -> identifier:'$1'.

-Reference -> typereference '{' '}':'$1'.

-Reference -> Externaltypereference '{' '}':'$1'.

-

-% later Reference -> objectclassreference :'$1'.

-% later Reference -> objectreference :'$1'.

-% later Reference -> objectsetreference :'$1'.

-

-AssignmentList -> Assignment : ['$1'].

-% modified AssignmentList -> AssignmentList Assignment : '$1'.

-AssignmentList -> Assignment AssignmentList : ['$1'|'$2'].

-

-Assignment -> TypeAssignment : '$1'.

-Assignment -> ValueAssignment : '$1'.

-% later Assignment -> ValueSetTypeAssignment : '$1'.

-Assignment -> ObjectClassAssignment : '$1'.

-% later Assignment -> ObjectAssignment : '$1'.

-% combined with ValueAssignment Assignment -> ObjectAssignment : '$1'.

-Assignment -> ObjectSetAssignment : '$1'.

-Assignment -> ParameterizedTypeAssignment : '$1'.

-%Assignment -> ParameterizedValueAssignment : '$1'.

-%Assignment -> ParameterizedValueSetTypeAssignment : '$1'.

-%Assignment -> ParameterizedObjectClassAssignment : '$1'.

-

-ObjectClassAssignment -> typereference '::=' 'CLASS' '{' FieldSpecs '}' :

-%ObjectClassAssignment -> objectclassreference '::=' 'CLASS' '{' FieldSpecs '}' :

-	#typedef{pos=element(2,'$1'),name=element(3,'$1'),typespec={'CLASS','$5',[]}}.

-ObjectClassAssignment -> typereference '::=' 'CLASS' '{' FieldSpecs '}' WithSyntaxSpec :

-%ObjectClassAssignment -> objectclassreference '::=' 'CLASS' '{' FieldSpecs '}' WithSyntaxSpec :

-	#typedef{pos=element(2,'$1'),name=element(3,'$1'),typespec={'CLASS','$5','$7'}}.

-

-FieldSpecs -> FieldSpec : ['$1'].

-FieldSpecs -> FieldSpec ',' FieldSpecs : ['$1'|'$3'].

-

-FieldSpec -> typefieldreference TypeOptionalitySpec : {typefield,'$1','$2'}.

-

-FieldSpec -> valuefieldreference Type 'UNIQUE' ValueOrObjectOptSpec : 

-	{fixedtypevaluefield,'$1','$2','UNIQUE','$4'}.

-FieldSpec -> valuefieldreference Type ValueOrObjectOptSpec : 

-	{fixedtypevaluefield,'$1','$2',undefined,'$3'}.

-

-FieldSpec -> valuefieldreference typefieldreference ValueOrObjectOptSpec :

-        {variabletypevaluefield, '$1','$2','$3'}.

-

-FieldSpec -> typefieldreference typefieldreference VSetOrOSetOptSpec : 

-        {variabletypevaluesetfield, '$1','$2','$3'}.

-

-FieldSpec -> typefieldreference Type VSetOrOSetOptSpec :

-        {fixedtypevaluesetfield, '$1','$2','$3'}.

-

-TypeOptionalitySpec -> 'DEFAULT' Type : {'DEFAULT','$2'}.

-TypeOptionalitySpec -> 'OPTIONAL' : 'OPTIONAL'.

-TypeOptionalitySpec -> '$empty' : 'MANDATORY'.

-

-ValueOrObjectOptSpec -> ValueOptionalitySpec : '$1'.

-ValueOrObjectOptSpec -> ObjectOptionalitySpec : '$1'.

-ValueOrObjectOptSpec -> 'OPTIONAL' : 'OPTIONAL'.

-ValueOrObjectOptSpec -> '$empty' : 'MANDATORY'.

-

-ValueOptionalitySpec -> 'DEFAULT' Value :

-	case '$2' of

-	{identifier,_,Id} -> {'DEFAULT',Id};

-	_ -> {'DEFAULT','$2'}

-	end.

-

-%ObjectOptionalitySpec -> 'DEFAULT' Object :{'DEFAULT','$1'}.

-ObjectOptionalitySpec -> 'DEFAULT'  '{' FieldSetting ',' FieldSettings '}' : 

-        {'DEFAULT',{object,['$2'|'$4']}}.

-ObjectOptionalitySpec -> 'DEFAULT'  '{' FieldSetting '}' :

-        {'DEFAULT',{object, ['$2']}}.

-%ObjectOptionalitySpec -> 'DEFAULT'  '{' DefinedSyntaxTokens '}' :

-%        {'DEFAULT',{object, '$2'}}.

-ObjectOptionalitySpec -> 'DEFAULT'  ObjectFromObject :

-        {'DEFAULT',{object, '$2'}}.

-

-

-VSetOrOSetOptSpec -> ValueSetOptionalitySpec : '$1'.

-%VSetOrOSetOptSpec -> ObjectSetOptionalitySpec : '$1'.

-VSetOrOSetOptSpec -> 'OPTIONAL' : 'OPTIONAL'.

-VSetOrOSetOptSpec -> '$empty' : 'MANDATORY'.

-

-ValueSetOptionalitySpec -> 'DEFAULT' ValueSet : {'DEFAULT','$1'}.

-

-%ObjectSetOptionalitySpec -> 'DEFAULT' ObjectSet : {'DEFAULT','$1'}.

-

-OptionalitySpec -> 'DEFAULT' Type : {'DEFAULT','$2'}.

-OptionalitySpec -> 'DEFAULT' ValueNotNull : 

-	case '$2' of

-	{identifier,_,Id} -> {'DEFAULT',Id};

-	_ -> {'DEFAULT','$2'}

-	end.

-OptionalitySpec -> 'OPTIONAL' : 'OPTIONAL'.

-OptionalitySpec -> '$empty' : 'MANDATORY'.

-

-WithSyntaxSpec -> 'WITH' 'SYNTAX' SyntaxList : {'WITH SYNTAX','$3'}.

-

-SyntaxList -> '{' TokenOrGroupSpecs '}' : '$2'.

-SyntaxList -> '{' '}' : [].

-

-TokenOrGroupSpecs -> TokenOrGroupSpec : ['$1'].

-TokenOrGroupSpecs -> TokenOrGroupSpec TokenOrGroupSpecs : ['$1'|'$2'].

-

-TokenOrGroupSpec -> RequiredToken : '$1'.

-TokenOrGroupSpec -> OptionalGroup : '$1'.

-

-OptionalGroup -> '[' TokenOrGroupSpecs ']' : '$2'.

-

-RequiredToken -> typereference : '$1'.

-RequiredToken -> Word : '$1'.

-RequiredToken -> ',' : '$1'.

-RequiredToken -> PrimitiveFieldName : '$1'.

-

-Word -> 'BY' : 'BY'.

- 

-ParameterizedTypeAssignment -> typereference ParameterList '::=' Type : 

-	#ptypedef{pos=element(2,'$1'),name=element(3,'$1'),

-	args='$2', typespec='$4'}.

-

-ParameterList -> '{' Parameters '}':'$2'.

-

-Parameters -> Parameter: ['$1'].

-Parameters -> Parameter ',' Parameters: ['$1'|'$3'].

-

-Parameter -> typereference: '$1'.

-Parameter -> Value: '$1'.

-Parameter -> Type ':' typereference: {'$1','$3'}.

-Parameter -> Type ':' Value: {'$1','$3'}.

-Parameter -> '{' typereference '}': {objectset,'$2'}.

-

-

-% Externaltypereference -> modulereference '.' typereference : {'$1','$3'} .

-Externaltypereference -> typereference '.' typereference : #'Externaltypereference'{pos=element(2,'$1'),module=element(3,'$1'),type=element(3,'$3')}.

-

-% Externalvaluereference -> modulereference '.' valuereference : {'$1','$3'} .

-% inlined Externalvaluereference -> typereference '.' identifier : #'Externalvaluereference'{pos=element(2,'$1'),module=element(3,'$1'),value=element(3,'$3')}.

-

-

-DefinedType -> Externaltypereference : '$1' .

-DefinedType -> typereference : 

-	#'Externaltypereference'{pos='$1'#typereference.pos,

-				module= get(asn1_module), 

-				type= '$1'#typereference.val} .

-DefinedType -> typereference ParameterList : {pt,'$1','$2'}.

-DefinedType -> Externaltypereference ParameterList : {pt,'$1','$2'}.

-

-% ActualParameterList -> '{' ActualParameters '}' : '$1'.

-

-% ActualParameters -> ActualParameter : ['$1']. 

-% ActualParameters -> ActualParameter ',' ActualParameters : ['$1'|'$3'].

-

-ActualParameter -> Type : '$1'. 

-ActualParameter -> ValueNotNull : '$1'. 

-ActualParameter -> ValueSet : '$1'. 

-% later DefinedType -> ParameterizedType : '$1' .

-% later DefinedType -> ParameterizedValueSetType : '$1' .

-

-% inlined DefinedValue -> Externalvaluereference :'$1'.

-% inlined DefinedValue -> identifier :'$1'.

-% later DefinedValue -> ParameterizedValue :'$1'.

-

-% not referenced yet AbsoluteReference -> '@' GlobalModuleReference '.' ItemSpec :{'$2','$4'}.

-

-% not referenced yet ItemSpec -> typereference :'$1'.

-% not referenced yet ItemSpec -> ItemId '.' ComponentId : {'$1','$3'}.

-

-% not referenced yet ItemId -> ItemSpec : '$1'.

-

-% not referenced yet ComponentId -> identifier :'$1'.

-% not referenced yet ComponentId -> number :'$1'.

-% not referenced yet ComponentId -> '*' :'$1'.

-

-TypeAssignment -> typereference '::=' Type :

-	#typedef{pos=element(2,'$1'),name=element(3,'$1'),typespec='$3'}.

-

-ValueAssignment -> identifier Type '::=' Value :

-	#valuedef{pos=element(2,'$1'),name=element(3,'$1'),type='$2',value='$4'}.

-

-% later ValueSetTypeAssignment -> typereference Type '::=' ValueSet :{'ValueSetTypeAssignment','$1','$2','$4'}.

-

-

-ValueSet -> '{' ElementSetSpec '}' : {valueset,'$2'}.

-

-% record(type,{tag,def,constraint}).

-Type -> BuiltinType :#type{def='$1'}.

-Type -> 'NULL' :#type{def='NULL'}.

-Type -> TaggedType:'$1'.

-Type -> ReferencedType:#type{def='$1'}. % change notag later

-Type -> ConstrainedType:'$1'.

-

-%ANY is here for compatibility with the old ASN.1 standard from 1988

-BuiltinType -> 'ANY' AnyDefBy: 

-	case '$2' of

-		[] -> 'ANY';

-	        _ -> {'ANY DEFINED BY','$2'}

-        end.	

-BuiltinType -> BitStringType :'$1'.

-BuiltinType -> 'BOOLEAN' :element(1,'$1').

-BuiltinType -> CharacterStringType :'$1'.

-BuiltinType -> ChoiceType :'$1'.

-BuiltinType -> 'EMBEDDED' 'PDV' :'EMBEDDED PDV'.

-BuiltinType -> EnumeratedType :'$1'.

-BuiltinType -> 'EXTERNAL' :element(1,'$1').

-% later BuiltinType -> InstanceOfType :'$1'.

-BuiltinType -> IntegerType :'$1'.

-% BuiltinType -> 'NULL' :element(1,'$1').

-% later BuiltinType -> ObjectClassFieldType :'$1'.

-BuiltinType -> 'OBJECT' 'IDENTIFIER' :'OBJECT IDENTIFIER'.

-BuiltinType -> 'OCTET' 'STRING' :'OCTET STRING'.

-BuiltinType -> 'REAL' :element(1,'$1').

-BuiltinType -> SequenceType :'$1'.

-BuiltinType -> SequenceOfType :'$1'.

-BuiltinType -> SetType :'$1'.

-BuiltinType -> SetOfType :'$1'.

-% The so called Useful types

-BuiltinType -> 'GeneralizedTime': 'GeneralizedTime'.

-BuiltinType -> 'UTCTime' :'UTCTime'.

-BuiltinType -> 'ObjectDescriptor' : 'ObjectDescriptor'.

-

-% moved BuiltinType -> TaggedType :'$1'.

-

-

-AnyDefBy -> 'DEFINED' 'BY' identifier: '$3'.

-AnyDefBy -> '$empty': [].

-

-NamedType -> identifier Type :

-%{_,Pos,Val} = '$1',

-%{'NamedType',Pos,{Val,'$2'}}.

-V1 = '$1', 

-{'NamedType',V1#identifier.pos,{V1#identifier.val,'$2'}}.

-NamedType -> SelectionType :'$1'.

-

-ReferencedType -> DefinedType : '$1'.

-% redundant ReferencedType -> UsefulType : 'fix'.

-ReferencedType -> SelectionType : '$1'.

-ReferencedType -> TypeFromObject : '$1'.

-% later ReferencedType -> ValueSetFromObjects : 'fix'.

-

-% to much conflicts Value -> AnyValue :'$1'.

-Value -> ValueNotNull : '$1'.

-Value -> 'NULL' :element(1,'$1').

-

-ValueNotNull -> BuiltinValue :'$1'.

-% inlined Value -> DefinedValue :'$1'. % DefinedValue , identifier

-% inlined Externalvaluereference -> Externalvaluereference :'$1'.

-ValueNotNull -> typereference '.' identifier : 

-	#'Externalvaluereference'{pos=element(2,'$1'),module=element(3,'$1'),

-	value=element(3,'$3')}.

-ValueNotNull -> identifier :'$1'.

-

-

-%tmp Value -> NamedNumber: '$1'. % not a value but part of ObjIdC

-% redundant BuiltinValue -> BitStringValue :'$1'.

-BuiltinValue -> BooleanValue :'$1'.

-BuiltinValue -> CharacterStringValue :'$1'.

-BuiltinValue -> ChoiceValue :'$1'.

-% BuiltinValue -> EmbeddedPDVValue :'$1'. ==SequenceValue

-% BuiltinValue -> EnumeratedValue :'$1'. identifier

-% BuiltinValue -> ExternalValue :'$1'. ==SequenceValue

-% later BuiltinValue -> InstanceOfValue :'$1'.

-BuiltinValue -> SignedNumber :'$1'.

-% BuiltinValue -> 'NULL' :'$1'.

-% later BuiltinValue -> ObjectClassFieldValue :'$1'.

-% replaced by SAndSOfValue BuiltinValue -> ObjectIdentifierValue :'$1'.

-BuiltinValue -> bstring :element(3,'$1').

-BuiltinValue -> hstring :element(3,'$1').

-% conflict BuiltinValue -> RealValue :'$1'.

-BuiltinValue -> SAndSOfValue :'$1'.

-% replaced BuiltinValue -> SequenceOfValue :'$1'.

-% replaced BuiltinValue -> SequenceValue :'$1'.

-% replaced BuiltinValue -> SetValue :'$1'.

-% replaced BuiltinValue -> SetOfValue :'$1'.

-% conflict redundant BuiltinValue -> TaggedValue :'$1'.

-

-% inlined ReferencedValue -> DefinedValue:'$1'.

-% ReferencedValue -> Externalvaluereference:'$1'.

-% ReferencedValue -> identifier :'$1'. 

-% later ReferencedValue -> ValueFromObject:'$1'.

-

-% inlined BooleanType -> BOOLEAN :'BOOLEAN'.

-

-% to much conflicts AnyValue -> Type ':' Value : {'ANYVALUE',{'$1','$3'}}.

-

-BooleanValue -> TRUE :true.

-BooleanValue -> FALSE :false.

-

-IntegerType -> 'INTEGER' : 'INTEGER'.

-IntegerType -> 'INTEGER' '{' NamedNumberList '}' : {'INTEGER','$3'}.

-

-NamedNumberList -> NamedNumber :['$1'].

-% modified NamedNumberList -> NamedNumberList ',' NamedNumber :'fix'.

-NamedNumberList -> NamedNumber ',' NamedNumberList :['$1'|'$3'].

-

-NamedNumber -> identifier '(' SignedNumber ')' : {'NamedNumber',element(3,'$1'),'$3'}.

-NamedNumber -> identifier '(' typereference '.' identifier ')' : {'NamedNumber',element(3,'$1'),{'ExternalValue',element(3,'$3'),element(3,'$5')}}.

-NamedNumber -> identifier '(' identifier ')' : {'NamedNumber',element(3,'$1'),element(3,'$3')}.

-

-%NamedValue -> identifier Value : 

-%	{'NamedValue',element(2,'$1'),element(3,'$1'),'$2'}.

-

-

-SignedNumber -> number : element(3,'$1').

-SignedNumber -> '-' number : - element(3,'$1').

-

-% inlined IntegerValue -> SignedNumber :'$1'.

-% conflict moved to Value IntegerValue -> identifier:'$1'.

-

-EnumeratedType -> ENUMERATED '{' Enumeration '}' :{'ENUMERATED','$3'}.

-

-% inlined Enumerations -> Enumeration :{'$1','false',[]}.

-% inlined Enumerations -> Enumeration ',' '...' : {'$1','true',[]}.

-% inlined Enumerations -> Enumeration ',' '...' ',' Enumeration : {'$1','true','$5'}.

-

-Enumeration -> EnumerationItem :['$1'].

-% modified Enumeration -> EnumerationItem ',' Enumeration :'fix'.

-Enumeration -> EnumerationItem ',' Enumeration :['$1'|'$3'].

-

-EnumerationItem -> identifier:element(3,'$1').

-EnumerationItem -> NamedNumber :'$1'.

-EnumerationItem -> '...' :'EXTENSIONMARK'.

-

-% conflict moved to Value EnumeratedValue -> identifier:'$1'.

-

-% inlined RealType -> REAL:'REAL'.

-

-RealValue -> NumericRealValue :'$1'.

-RealValue -> SpecialRealValue:'$1'.

-

-% ?? NumericRealValue -> number:'$1'. % number MUST BE '0'

-NumericRealValue -> SAndSOfValue : '$1'. % Value of the associated sequence type

-

-SpecialRealValue -> 'PLUS-INFINITY' :'$1'.

-SpecialRealValue -> 'MINUS-INFINITY' :'$1'.

-

-BitStringType -> 'BIT' 'STRING' :{'BIT STRING',[]}.

-BitStringType -> 'BIT' 'STRING' '{' NamedNumberList '}' :{'BIT STRING','$4'}.

-% NamedBitList replaced by NamedNumberList to reduce the grammar

-% Must check later that all "numbers" are positive

-

-% inlined BitStringValue -> bstring:'$1'.

-% inlined BitStringValue -> hstring:'$1'.

-% redundant use SequenceValue BitStringValue -> '{' IdentifierList '}' :$2.

-% redundant use SequenceValue BitStringValue -> '{' '}' :'fix'.

-

-IdentifierList -> identifier :[element(3,'$1')].

-% modified IdentifierList -> IdentifierList ',' identifier :'$1'.

-IdentifierList -> identifier ',' IdentifierList :[element(3,'$1')|'$3'].

-

-% inlined OctetStringType -> 'OCTET' 'STRING' :'OCTET STRING'.

-

-% inlined OctetStringValue -> bstring:'$1'.

-% inlined OctetStringValue -> hstring:'$1'.

-

-% inlined NullType -> 'NULL':'NULL'.

-

-% inlined NullValue -> NULL:'NULL'.

-

-% result is {'SEQUENCE',Optionals,Extensionmark,Componenttypelist}.

-SequenceType -> SEQUENCE '{' ComponentTypeList '}' :{'SEQUENCE','$3'}.

-% SequenceType -> SEQUENCE '{' ComponentTypeLists '}' :{'SEQUENCE','$3'}.

-% SequenceType -> SEQUENCE '{' ExtensionAndException '}' :{'SEQUENCE','$3'}.

-SequenceType -> SEQUENCE '{' '}' :{'SEQUENCE',[]}.

-

-% result is {RootComponentList,ExtensionAndException,AdditionalComponentTypeList}.

-%ComponentTypeLists -> ComponentTypeList ',' ExtensionAndException :{'$1','$3',[]}.

-%ComponentTypeLists -> ComponentTypeList :{'$1','false',[]}.

-%ComponentTypeLists -> ComponentTypeList ',' ExtensionAndException 

-%	',' ComponentTypeList :{'$1','$3', '$5'}.

-%ComponentTypeLists -> ExtensionAndException ',' ComponentTypeList :{[],'$1','$3'}.

-

-ComponentTypeList -> ComponentType :['$1'].

-% modified below ComponentTypeList -> ComponentTypeList ',' ComponentType :'$1'.

-ComponentTypeList -> ComponentType ',' ComponentTypeList  :['$1'|'$3'].

-

-% -record('ComponentType',{pos,name,type,attrib}).

-ComponentType -> '...' ExceptionSpec :{'EXTENSIONMARK',element(2,'$1'),'$2'}.

-ComponentType -> NamedType :

-	{'NamedType',Pos,{Name,Type}} = '$1',

-	#'ComponentType'{pos=Pos,name=Name,typespec=Type,prop=mandatory}.

-ComponentType -> NamedType 'OPTIONAL' : 

-	{'NamedType',Pos,{Name,Type}} = '$1',

-	#'ComponentType'{pos=Pos,name=Name,typespec=Type,prop='OPTIONAL'}.

-ComponentType -> NamedType 'DEFAULT' Value:

-	{'NamedType',Pos,{Name,Type}} = '$1',

-	#'ComponentType'{pos=Pos,name=Name,typespec=Type,prop={'DEFAULT','$3'}}.

-ComponentType -> 'COMPONENTS' 'OF' Type :{'COMPONENTS OF','$3'}.

-

-% redundant ExtensionAndException -> '...' : extensionmark.

-% ExtensionAndException -> '...' ExceptionSpec : {extensionmark,'$2'}.

-

-% replaced SequenceValue -> '{' ComponentValueList '}':'$2'.

-% replaced SequenceValue -> '{'  '}':[].

-

-ValueList -> Value :['$1'].

-ValueList -> NamedNumber :['$1'].

-% modified ValueList -> ValueList ',' Value :'$1'.

-ValueList -> Value ',' ValueList :['$1'|'$3'].

-ValueList -> Value ',' '...' :['$1' |[]].

-ValueList -> Value ValueList : ['$1',space|'$2'].

-ValueList -> NamedNumber ValueList: ['$1',space|'$2'].

-

-%ComponentValueList -> identifier ObjIdComponent:[{'NamedValue','$1','$2'}].

-%ComponentValueList -> NamedValue :['$1'].

-%ComponentValueList -> NamedValue ',' ComponentValueList:['$1'|'$3'].

-%ComponentValueList -> identifier ObjIdComponent ',' ComponentValueList :[{'NamedValue', '$1','$2'}|'$4'].

-

-SequenceOfType -> SEQUENCE OF Type : {'SEQUENCE OF','$3'}.

-

-% replaced SequenceOfValue with SAndSOfValue

-

-SAndSOfValue -> '{' ValueList '}' :'$2'.

-%SAndSOfValue -> '{' ComponentValueList '}' :'$2'.

-SAndSOfValue -> '{'  '}' :[].

-

-% save for later SetType ->

-% result is {'SET',Optionals,Extensionmark,Componenttypelist}.

-SetType -> SET '{' ComponentTypeList '}' :{'SET','$3'}.

-% SetType -> SET '{' ExtensionAndException '}' :{'SET','$3'}.

-SetType -> SET '{' '}' :{'SET',[]}.

-

-% replaced SetValue with SAndSOfValue

-

-SetOfType -> SET OF Type : {'SET OF','$3'}.

-

-% replaced SetOfValue with SAndSOfValue

-

-ChoiceType -> 'CHOICE' '{' ComponentTypeList '}' :{'CHOICE','$3'}.

-%  AlternativeTypeList is replaced by ComponentTypeList

-ChoiceValue -> identifier ':' Value : {'ChoiceValue',element(3,'$1'),'$3'}.

-% save for later SelectionType ->

-

-TaggedType -> Tag Type : '$2'#type{tag=['$1'#tag{type={default,get(tagdefault)}}]}.

-TaggedType -> Tag IMPLICIT Type :'$3'#type{tag=['$1'#tag{type='IMPLICIT'}]}.

-TaggedType -> Tag EXPLICIT Type :'$3'#type{tag=['$1'#tag{type='EXPLICIT'}]}.

-

-Tag -> '[' Class ClassNumber ']': #tag{class='$2',number='$3'}.

-Tag -> '[' Class typereference '.' identifier ']': 

-	#tag{class='$2',number=#'Externalvaluereference'{pos=element(2,'$3'),module=element(3,'$3'),

-	value=element(3,'$5')}}.

-Tag -> '[' Class number ']': #tag{class='$2',number=element(3,'$3')}.

-Tag -> '[' Class identifier ']': #tag{class='$2',number=element(3,'$3')}.

-

-ClassNumber -> number :element(3,'$1').

-% inlined above ClassNumber -> typereference '.' identifier :{'Externalvaluereference',element(3,'$1'),element(3,'$3')}.

-ClassNumber -> identifier :element(3,'$1').

-

-Class -> 'UNIVERSAL' :element(1,'$1').

-Class -> 'APPLICATION' :element(1,'$1').

-Class -> 'PRIVATE' :element(1,'$1').

-Class -> '$empty' :'CONTEXT'.

-

-% conflict redundant TaggedValue -> Value:'$1'.

-

-% inlined EmbeddedPDVType -> 'EMBEDDED' 'PDV' :'EMBEDDED PDV'.

-

-% inlined EmbeddedPDVValue -> SequenceValue:'$1'.

-

-% inlined ExternalType -> 'EXTERNAL' :'EXTERNAL'.

-

-% inlined ExternalValue -> SequenceValue :'$1'.

-

-% inlined ObjectIdentifierType -> 'OBJECT' 'IDENTIFIER' :'OBJECT IDENTIFIER'.

-

-ObjectIdentifierValue -> '{' ObjIdComponentList '}' :'$2'.

-%  inlined ObjectIdentifierValue -> SequenceAndSequenceOfValue :'$1'.

-% ObjectIdentifierValue -> '{' identifier ObjIdComponentList '}' :{'ObjectIdentifierValue','$2','$3'}.

-% ObjectIdentifierValue -> '{' typereference '.' identifier ObjIdComponentList '}' :{'ObjectIdentifierValue',{'$2','$4'},'$5'}.

-

-ObjIdComponentList -> Value:'$1'.

-ObjIdComponentList -> Value ObjIdComponentList :['$1'|'$2'].

-%ObjIdComponentList -> DefinedValue:'$1'.

-%ObjIdComponentList -> number:'$1'.

-%ObjIdComponentList -> DefinedValue ObjIdComponentList :['$1'|'$2'].

-%ObjIdComponentList -> number ObjIdComponentList :['$1'|'$2'].

-%ObjIdComponentList -> ObjIdComponent ObjIdComponentList :['$1'|'$2'].

-%ObjIdComponentList -> ObjIdComponent ObjIdComponentList :['$1'|'$2'].

-

-% redundant ObjIdComponent -> NameForm :'$1'. % expanded

-% replaced by 2 ObjIdComponent -> NumberForm :'$1'.

-% ObjIdComponent -> number :'$1'.

-% ObjIdComponent -> DefinedValue :'$1'. % means DefinedValue

-% ObjIdComponent -> NameAndNumberForm :'$1'.

-% ObjIdComponent -> NamedNumber :'$1'.

-% NamedBit replaced by NamedNumber to reduce grammar

-% must check later that "number" is positive

-

-% NameForm -> identifier:'$1'.

-

-% inlined NumberForm -> number :'$1'.

-% inlined NumberForm -> DefinedValue :'$1'.

-

-% replaced by NamedBit  NameAndNumberForm -> identifier '(' NumberForm ')'.

-% NameAndNumberForm -> NamedBit:'$1'.

-

-

-CharacterStringType -> restrictedcharacterstringtype :element(3,'$1').

-CharacterStringType -> 'CHARACTER' 'STRING' :'CHARACTER STRING'.

-

-RestrictedCharacterStringValue -> cstring :element(3, '$1').

-% modified below RestrictedCharacterStringValue -> CharacterStringList :'$1'.

-% conflict vs BuiltinValue RestrictedCharacterStringValue -> SequenceAndSequenceOfValue :'$1'.

-RestrictedCharacterStringValue -> Quadruple :'$1'.

-RestrictedCharacterStringValue -> Tuple :'$1'.

-

-% redundant CharacterStringList -> '{' ValueList '}' :'$2'. % modified

-

-% redundant CharSyms -> CharsDefn :'$1'.

-% redundant CharSyms -> CharSyms ',' CharsDefn :['$1'|'$3'].

-

-% redundant CharsDefn -> cstring :'$1'.

-% temporary replaced see below CharsDefn -> DefinedValue :'$1'.

-% redundant CharsDefn -> Value :'$1'.

-

-Quadruple -> '{' number ',' number ',' number ',' number '}' :{'Quadruple','$2','$4','$6','$8'}.

-% {Group,Plane,Row,Cell}

-

-Tuple -> '{' number ',' number '}' :{'Tuple', '$2','$4'}.

-% {TableColumn,TableRow}

-

-% inlined UnrestrictedCharacterString -> 'CHARACTER' 'STRING' :'CHARACTER STRING'.

-

-CharacterStringValue -> RestrictedCharacterStringValue :'$1'.

-% conflict vs BuiltinValue CharacterStringValue -> SequenceValue :'$1'. % UnrestrictedCharacterStringValue

-

-% inlined UsefulType -> typereference :'$1'.

-

-SelectionType -> identifier '<' Type : {'SelectionType',element(3,'$1'),'$3'}.

-

-ConstrainedType -> Type Constraint :

-	'$1'#type{constraint=merge_constraints(['$2'])}.

-ConstrainedType -> Type Constraint Constraint :

-	'$1'#type{constraint=merge_constraints(['$2','$3'])}.

-ConstrainedType -> Type Constraint Constraint Constraint:

-	'$1'#type{constraint=merge_constraints(['$2','$3','$4'])}.

-ConstrainedType -> Type Constraint Constraint Constraint Constraint:

-	'$1'#type{constraint=merge_constraints(['$2','$3','$4','$5'])}.

-%ConstrainedType -> Type Constraint :'$1'#type{constraint='$2'}.

-%ConstrainedType -> Type Constraint :'$1'#type{constraint='$2'}.

-ConstrainedType -> TypeWithConstraint :'$1'.

-

-TypeWithConstraint -> 'SET' Constraint 'OF' Type : 

-	#type{def = {'SET OF','$4'},constraint=merge_constraints(['$2'])}.		

-TypeWithConstraint -> 'SET' 'SIZE' Constraint 'OF' Type : 

-	#type{def = {'SET OF','$5'},constraint = merge_constraints([#constraint{c={'SizeConstraint','$3'#constraint.c}}])}.

-TypeWithConstraint -> 'SEQUENCE' Constraint 'OF' Type : 

-	#type{def = {'SEQUENCE OF','$4'},constraint = 

-	merge_constraints(['$2'])}.

-TypeWithConstraint -> 'SEQUENCE' 'SIZE' Constraint 'OF' Type : 

-	#type{def = {'SEQUENCE OF','$5'},constraint = merge_constraints([#constraint{c={'SizeConstraint','$3'#constraint.c}}])}.

-

-

-Constraint -> '(' ConstraintSpec ExceptionSpec ')' :

-		#constraint{c='$2',e='$3'}.

-

-% inlined Constraint -> SubTypeConstraint :'$1'.

-ConstraintSpec -> ElementSetSpecs :'$1'.

-ConstraintSpec -> UserDefinedConstraint :'$1'.

-ConstraintSpec -> TableConstraint :'$1'.

-

-TableConstraint -> ComponentRelationConstraint : '$1'.

-TableConstraint -> ObjectSet : '$1'.

-%TableConstraint -> '{' typereference '}' :tableconstraint.

-

-ComponentRelationConstraint -> '{' typereference '}' '{' '@' ComponentIdList '}' : componentrelation.

-ComponentRelationConstraint -> '{' typereference '}' '{' '@' '.' ComponentIdList '}' : componentrelation.

-

-ComponentIdList -> identifier: ['$1'].

-ComponentIdList -> identifier '.' ComponentIdList: ['$1'| '$3'].

-

-

-% later ConstraintSpec -> GeneralConstraint :'$1'.

-

-% from X.682

-UserDefinedConstraint -> 'CONSTRAINED' 'BY' '{' '}' : {constrained_by,[]}.

-UserDefinedConstraint -> 'CONSTRAINED' 'BY' 

-	'{' UserDefinedConstraintParameters '}' : {constrained_by,'$4'}.

-

-UserDefinedConstraintParameters -> UserDefinedConstraintParameter : ['$1'].

-UserDefinedConstraintParameters -> 

-	UserDefinedConstraintParameter ',' 

-	UserDefinedConstraintParameters: ['$1'|'$3'].

-

-UserDefinedConstraintParameter -> Type '.' ActualParameter : {'$1','$3'}.

-UserDefinedConstraintParameter -> ActualParameter : '$1'.

-

-

-

-ExceptionSpec -> '!' ExceptionIdentification : '$1'.

-ExceptionSpec -> '$empty' : undefined.

-

-ExceptionIdentification -> SignedNumber : '$1'.

-% inlined ExceptionIdentification -> DefinedValue : '$1'.

-ExceptionIdentification -> typereference '.' identifier : 

-	#'Externalvaluereference'{pos=element(2,'$1'),module=element(3,'$1'),

-	value=element(3,'$1')}.

-ExceptionIdentification -> identifier :'$1'.

-ExceptionIdentification -> Type ':' Value : {'$1','$3'}.

-

-% inlined SubTypeConstraint -> ElementSetSpec

-

-ElementSetSpecs -> ElementSetSpec : '$1'.

-ElementSetSpecs -> ElementSetSpec ',' '...': {'$1',[]}.

-ElementSetSpecs -> '...' ',' ElementSetSpec : {[],'$3'}.

-ElementSetSpecs -> ElementSetSpec ',' '...' ',' ElementSetSpec : {'$1','$5'}.

-

-ElementSetSpec -> Unions : '$1'.

-ElementSetSpec -> 'ALL' Exclusions : {'ALL','$2'}.

-

-Unions -> Intersections : '$1'.

-Unions -> UElems UnionMark IntersectionElements :

-	case {'$1','$3'} of	

-	{{'SingleValue',V1},{'SingleValue',V2}} -> 

-		{'SingleValue',ordsets:union(to_set(V1),to_set(V2))} 

-	end.

-

-UElems -> Unions :'$1'.

-

-Intersections -> IntersectionElements :'$1'.

-Intersections -> IElems IntersectionMark IntersectionElements :

-	case {'$1','$3'} of 

-	{{'SingleValue',V1},{'SingleValue',V2}} ->

-		{'SingleValue',ordsets:intersection(to_set(V1),to_set(V2))};

-	{V1,V2} when list(V1) ->

-	        V1 ++ [V2];

-	{V1,V2} ->

-	        [V1,V2]  

-	end.

-%Intersections -> IElems '^' IntersectionElements :{'INTERSECTION','$1','$3'}.

-%Intersections -> IElems 'INTERSECTION' IntersectionElements :{'INTERSECTION','$1','$3'}.

-

-IElems -> Intersections :'$1'.

-

-IntersectionElements -> Elements :'$1'.

-IntersectionElements -> Elems Exclusions :{'$1','$2'}.

-

-Elems -> Elements :'$1'.

-

-Exclusions -> 'EXCEPT' Elements :{'EXCEPT','$2'}.

-

-IntersectionMark -> 'INTERSECTION':'$1'.

-IntersectionMark -> '^':'$1'.

-UnionMark -> 'UNION':'$1'.

-UnionMark -> '|':'$1'.

-

-

-Elements -> SubTypeElements : '$1'.

-%Elements -> ObjectSetElements : '$1'.

-Elements -> '(' ElementSetSpec ')' : '$2'.

-Elements -> ReferencedType : '$1'.

-

-SubTypeElements -> ValueList : {'SingleValue','$1'}. % NOTE it must be a Value

-% The rule above modifyed only because of conflicts

-SubTypeElements -> 'INCLUDES' Type : {'ContainedSubType','$2'}.

-%not lalr1 if this is activated SubTypeElements -> Type : {'TypeConstraint','$1'}.

-SubTypeElements -> LowerEndpoint '..' UpperEndpoint : {'ValueRange',{'$1','$3'}}.

-SubTypeElements -> 'FROM' Constraint : {'PermittedAlphabet','$2'#constraint.c}.

-SubTypeElements -> 'SIZE' Constraint: {'SizeConstraint','$2'#constraint.c}.

-% later will introduce conflicts related to NULL SubTypeElements -> Type : {'TypeConstraint','$1'}.

-SubTypeElements -> 'WITH' 'COMPONENT' Constraint:{'WITH COMPONENT','$3'}.

-SubTypeElements -> 'WITH' 'COMPONENTS' '{' TypeConstraints '}':{'WITH COMPONENTS',{'FullSpecification','$4'}}.

-SubTypeElements -> 'WITH' 'COMPONENTS' '{' '...' ',' TypeConstraints '}' :{'WITH COMPONENTS',{'PartialSpecification','$3'}}.

-

-% inlined above InnerTypeConstraints ::= 

-% inlined above	SingleTypeConstraint::= Constraint

-% inlined above MultipleTypeConstraints ::= FullSpecification | PartialSpecification

-% inlined above FullSpecification   ::= "{" TypeConstraints "}"

-% inlined above PartialSpecification ::= "{"  "..."   ","   TypeConstraints "}"

-% TypeConstraints -> identifier : [{'NamedConstraint',element(3,'$1'),undefined,undefined}]. % is this really meaningful or allowed

-TypeConstraints -> NamedConstraint : ['$1'].

-TypeConstraints -> NamedConstraint ',' TypeConstraints : ['$1'|'$3'].

-TypeConstraints -> identifier : ['$1'].

-TypeConstraints -> identifier ',' TypeConstraints : ['$1'|'$3'].

-

-NamedConstraint -> identifier Constraint PresenceConstraint :{'NamedConstraint',element(3,'$1'),'$2','$3'}.

-NamedConstraint -> identifier Constraint  :{'NamedConstraint',element(3,'$1'),'$2',undefined}.

-NamedConstraint -> identifier PresenceConstraint :{'NamedConstraint',element(3,'$1'),undefined,'$2'}.

-

-PresenceConstraint -> 'PRESENT' : 'PRESENT'.

-PresenceConstraint -> 'ABSENT' : 'ABSENT'.

-PresenceConstraint -> 'OPTIONAL' : 'OPTIONAL'.

-

-

-

-LowerEndpoint -> LowerEndValue :'$1'.

-%LowerEndpoint -> LowerEndValue '<':{gt,'$1'}.

-LowerEndpoint -> LowerEndValue '<':('$1'+1).

-

-UpperEndpoint -> UpperEndValue :'$1'.

-%UpperEndpoint -> '<' UpperEndValue :{lt,'$2'}.

-UpperEndpoint -> '<' UpperEndValue :('$2'-1).

-

-LowerEndValue -> Value :'$1'.

-LowerEndValue -> 'MIN' :'MIN'.

-

-UpperEndValue -> Value :'$1'.

-UpperEndValue -> 'MAX' :'MAX'.

-

-

-% X.681 

-

-

-% X.681 chap 15

-

-%TypeFromObject -> ReferencedObjects '.' FieldName : {'$1','$3'}.

-TypeFromObject -> typereference '.' FieldName : {'$1','$3'}.

-

-ReferencedObjects -> typereference : '$1'.

-%ReferencedObjects -> ParameterizedObject

-%ReferencedObjects -> DefinedObjectSet

-%ReferencedObjects -> ParameterizedObjectSet

-

-FieldName -> typefieldreference : ['$1'].

-FieldName -> valuefieldreference : ['$1'].

-FieldName -> FieldName '.' FieldName : ['$1' | '$3'].

-

-PrimitiveFieldName -> typefieldreference : '$1'.

-PrimitiveFieldName -> valuefieldreference : '$1'.

-

-%ObjectSetAssignment -> typereference DefinedObjectClass '::=' ObjectSet: null.

-ObjectSetAssignment -> typereference typereference '::=' ObjectSet :

-	#typedef{pos=element(2,'$1'),name=element(3,'$1'),typespec={'ObjectSet',element(3,'$2'), '$4'}}.	

-ObjectSetAssignment -> typereference typereference '.' typereference '::=' ObjectSet.

-

-ObjectSet -> '{' ElementSetSpecs '}' : '$2'.

-ObjectSet -> '{' '...' '}' : ['EXTENSIONMARK'].

-

-%ObjectSetElements -> Object.

-% ObjectSetElements -> identifier : '$1'.

-%ObjectSetElements -> DefinedObjectSet.

-%ObjectSetElements -> ObjectSetFromObjects.

-%ObjectSetElements -> ParameterizedObjectSet.

-

-%ObjectAssignment -> identifier DefinedObjectClass '::=' Object.

-ObjectAssignment -> ValueAssignment.

-%ObjectAssignment -> identifier typereference '::=' Object.

-%ObjectAssignment -> identifier typereference '.' typereference '::=' Object.

-

-%Object -> DefinedObject: '$1'.

-%Object -> ExternalObjectReference: '$1'.%Object -> DefinedObject: '$1'.

-Object -> typereference '.' identifier: '$1'.%Object -> DefinedObject: '$1'.

-Object -> identifier: '$1'.%Object -> DefinedObject: '$1'.

-

-%Object -> ObjectDefn -> DefaultSyntax: '$1'.

-Object -> '{' FieldSetting ',' FieldSettings '}' : ['$2'|'$4'].

-Object -> '{' FieldSetting '}' :['$2'].

-

-%% For User-friendly notation

-%% Object -> ObjectDefn -> DefinedSyntax

-Object -> '{' '}'. 

-Object -> '{' DefinedSyntaxTokens '}'.

-

-% later Object -> ParameterizedObject: '$1'. look in x.683

-

-%DefinedObject -> ExternalObjectReference: '$1'.

-%DefinedObject -> identifier: '$1'.

-

-DefinedObjectClass -> typereference.

-%DefinedObjectClass -> objectclassreference.

-DefinedObjectClass -> ExternalObjectClassReference.

-%DefinedObjectClass -> typereference '.' objectclassreference.

-%%DefinedObjectClass -> UsefulObjectClassReference.

-

-ExternalObjectReference -> typereference '.' identifier.

-ExternalObjectClassReference -> typereference '.' typereference.

-%%ExternalObjectClassReference -> typereference '.' objectclassreference.

-

-ObjectDefn -> DefaultSyntax: '$1'.

-%ObjectDefn -> DefinedSyntax: '$1'.

-

-ObjectFromObject -> ReferencedObjects '.' FieldName : {'ObjectFromObject','$1','$3'}.

-

-% later look in x.683 ParameterizedObject ->

-

-%DefaultSyntax -> '{' '}'. 

-%DefaultSyntax -> '{' FieldSettings '}': '$2'.

-DefaultSyntax -> '{' FieldSetting ',' FieldSettings '}': '$2'.

-DefaultSyntax -> '{' FieldSetting '}': '$2'.

-

-FieldSetting -> PrimitiveFieldName Setting: {'$1','$2'}.

-

-FieldSettings -> FieldSetting ',' FieldSettings: ['$1'|'$3'].

-FieldSettings -> FieldSetting ',' FieldSettings: ['$1'|'$3'].

-FieldSettings -> FieldSetting: '$1'.

-

-%DefinedSyntax -> '{' '}'.

-DefinedSyntax -> '{' DefinedSyntaxTokens '}': '$2'.

-

-DefinedSyntaxTokens -> DefinedSyntaxToken: '$1'.

-DefinedSyntaxTokens -> DefinedSyntaxToken DefinedSyntaxTokens: ['$1'|'$2'].

-

-% expanded DefinedSyntaxToken -> Literal: '$1'.

-%DefinedSyntaxToken -> typereference: '$1'.

-DefinedSyntaxToken -> word: '$1'.

-DefinedSyntaxToken -> ',': '$1'.

-DefinedSyntaxToken -> Setting: '$1'.

-%DefinedSyntaxToken -> '$empty': nil .

-

-% Setting ::= Type|Value|ValueSet|Object|ObjectSet

-Setting -> Type: '$1'.

-%Setting -> Value: '$1'.

-%Setting -> ValueNotNull: '$1'.

-Setting -> BuiltinValue: '$1'.

-Setting -> ValueSet: '$1'.

-%Setting -> Object: '$1'.

-%Setting -> ExternalObjectReference.

-Setting -> typereference '.' identifier. 

-Setting -> identifier. 

-Setting -> ObjectDefn.

-

-Setting -> ObjectSet: '$1'.

-

-

-Erlang code.

-%%-author('[email protected]').

--copyright('Copyright (c) 1991-99 Ericsson Telecom AB').

--vsn('$Revision: /main/release/1 $').

--include("asn1_records.hrl").

-

-to_set(V) when list(V) ->

-	ordsets:list_to_set(V);

-to_set(V) ->

-	ordsets:list_to_set([V]).

-

-merge_constraints({Rlist,ExtList}) -> % extensionmarker in constraint

-	{merge_constraints(Rlist,[],[]),

-	 merge_constraints(ExtList,[],[])};

-	

-merge_constraints(Clist) ->

-	merge_constraints(Clist, [], []).

-

-merge_constraints([Ch|Ct],Cacc, Eacc) ->

-	NewEacc = case Ch#constraint.e of

-			undefined -> Eacc;

-			E -> [E|Eacc]

-		  end,

-	merge_constraints(Ct,[fixup_constraint(Ch#constraint.c)|Cacc],NewEacc);

-

-merge_constraints([],Cacc,[]) ->

-	lists:flatten(Cacc);

-merge_constraints([],Cacc,Eacc) ->

-	lists:flatten(Cacc) ++ [{'Errors',Eacc}].

-

-fixup_constraint(C) ->

-	case C of	

-		{'SingleValue',V} when list(V) ->

-			[C, 

-			{'ValueRange',{lists:min(V),lists:max(V)}}]; 

-		{'PermittedAlphabet',{'SingleValue',V}} when list(V) ->

-			V2 = {'SingleValue',

-			       ordsets:list_to_set(lists:flatten(V))},

-			{'PermittedAlphabet',V2};

-		{'PermittedAlphabet',{'SingleValue',V}} ->

-			V2 = {'SingleValue',[V]},

-			{'PermittedAlphabet',V2};

-		{'SizeConstraint',Sc} ->

-			{'SizeConstraint',fixup_size_constraint(Sc)};

-

-		List when list(List) ->

-			[fixup_constraint(Xc)||Xc <- List]; 	

-		Other ->

-			Other

-	end.

-

-fixup_size_constraint({'ValueRange',{Lb,Ub}}) ->

-	{Lb,Ub};

-fixup_size_constraint({{'ValueRange',R},[]}) ->

-	{R,[]};

-fixup_size_constraint({[],{'ValueRange',R}}) ->

-	{[],R};

-fixup_size_constraint({{'ValueRange',R1},{'ValueRange',R2}}) ->

-	{R1,R2};

-fixup_size_constraint({'SingleValue',[Sv]}) ->

-	fixup_size_constraint({'SingleValue',Sv});

-fixup_size_constraint({'SingleValue',L}) when list(L) ->

-	ordsets:list_to_set(L);

-fixup_size_constraint({'SingleValue',L}) ->

-	{L,L};

-fixup_size_constraint({C1,C2}) ->

-	{fixup_size_constraint(C1), fixup_size_constraint(C2)}.

-

-

-

-

-

-

-

-

-

-

-

-

-

diff --git a/lib/asn1/src/asn1ct_parser2.erl b/lib/asn1/src/asn1ct_parser2.erl
index 1abccc8626..2de9b0e2f0 100644
--- a/lib/asn1/src/asn1ct_parser2.erl
+++ b/lib/asn1/src/asn1ct_parser2.erl
@@ -2,52 +2,75 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2000-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2000-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
 %%
 -module(asn1ct_parser2).
 
--export([parse/1]).
+-export([parse/2,format_error/1]).
 -include("asn1_records.hrl").
 
 %% Only used internally within this module.
 -record(typereference, {pos,val}).
--record(constraint,{c,e}).
-
-%% parse all types in module
-parse(Tokens) ->
-    case catch parse_ModuleDefinition(Tokens) of
-	{'EXIT',Reason} ->
-	    {error,{{undefined,get(asn1_module),
-		    [internal,error,'when',parsing,module,definition,Reason]},
-		    hd(Tokens)}};
-	{asn1_error,Reason} ->
-	    {error,{Reason,hd(Tokens)}};
-	{ModuleDefinition,Rest1} ->
-	    {Types,Rest2} = parse_AssignmentList(Rest1),
-	    case Rest2 of
-		[{'END',_}|_Rest3] ->
-		    {ok,ModuleDefinition#module{typeorval = Types}};
-		_  ->
-		    {error,{{get_line(hd(Rest2)),get(asn1_module),
-			     [got,get_token(hd(Rest2)),expected,'END']},
-			    hd(Rest2)}}
-	    end
+-record(constraint, {c,e}).
+-record(identifier, {pos,val}).
+
+parse(File0, Tokens0) ->
+    try do_parse(Tokens0) of
+	{ok,#module{}}=Result ->
+	    Result
+    catch
+	throw:{asn1_error,Fun} when is_function(Fun, 0) ->
+	    handle_parse_error(File0, Fun());
+	throw:{asn1_error,{parse_error,Tokens}} ->
+	    handle_parse_error(File0, Tokens)
+    after
+	clean_process_dictionary()
+    end.
+
+handle_parse_error(File0, [Token|_]) ->
+    File = filename:basename(File0),
+    Line = get_line(Token),
+    Error = {structured_error,{File,Line},?MODULE,
+	     {syntax_error,get_token(Token)}},
+    {error,[Error]}.
+
+do_parse(Tokens0) ->
+    {ModuleDefinition,Tokens1} = parse_ModuleDefinition(Tokens0),
+    {Types,Tokens2} = parse_AssignmentList(Tokens1),
+    case Tokens2 of
+	[{'END',_}|_Rest3] ->
+	    {ok,ModuleDefinition#module{typeorval=Types}};
+	_  ->
+	    parse_error(Tokens2)
     end.
 
+clean_process_dictionary() ->
+    Mod = erase(asn1_module),
+    _ = erase({Mod,imports}),
+    _ = erase(tagdefault),
+    _ = erase(extensiondefault),
+    ok.
+
+format_error({syntax_error,Token}) when is_atom(Token) ->
+    io_lib:format("syntax error before: '~s'", [Token]);
+format_error({syntax_error,Token}) ->
+    io_lib:format("syntax error before: '~p'", [Token]).
+
 parse_ModuleDefinition([{typereference,L1,ModuleIdentifier}|Rest0]) ->
     put(asn1_module,ModuleIdentifier),
     {_DefinitiveIdentifier,Rest02} = 
@@ -61,9 +84,7 @@ parse_ModuleDefinition([{typereference,L1,ModuleIdentifier}|Rest0]) ->
 	       [{'DEFINITIONS',_}|Rest03] ->
 		   Rest03;
 	       _ ->
-		   throw({asn1_error,{get_line(hd(Rest02)),get(asn1_module),
-				      [got,get_token(hd(Rest02)),
-				       expected,'DEFINITIONS']}})
+		   parse_error(Rest02)
 	   end,
     {TagDefault,Rest2} = 
 	case Rest of
@@ -95,23 +116,24 @@ parse_ModuleDefinition([{typereference,L1,ModuleIdentifier}|Rest0]) ->
 		     extensiondefault = ExtensionDefault,
 		     exports = Exports,
 		     imports = {imports, Imports}}, Rest6};
-	_ -> throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
-				[got,get_token(hd(Rest3)),expected,"::= BEGIN"]}})
+	_ ->
+	    parse_error(Rest3)
     end;
 parse_ModuleDefinition(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,typereference]}}).
+    parse_error(Tokens).
     
 parse_Exports([{'EXPORTS',_L1},{';',_L2}|Rest]) ->
     {{exports,[]},Rest};
+parse_Exports([{'EXPORTS',_},{'ALL',_},{';',_}|Rest]) ->
+    %% Same as no exports definition.
+    {{exports,all},Rest};
 parse_Exports([{'EXPORTS',_L1}|Rest]) ->
     {SymbolList,Rest2} = parse_SymbolList(Rest),
     case Rest2 of
 	[{';',_}|Rest3] ->    
 	    {{exports,SymbolList},Rest3};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,';']}})
+	    parse_error(Rest2)
     end;
 parse_Exports(Rest) ->
     {{exports,all},Rest}.
@@ -125,29 +147,25 @@ parse_SymbolList(Tokens,Acc) ->
 	[{',',_L1}|Rest2] ->
 	    parse_SymbolList(Rest2,[Symbol|Acc]);
 	Rest2  ->
-	    {lists:reverse([Symbol|Acc]),Rest2}
+	    {lists:reverse(Acc, [Symbol]),Rest2}
     end.
 
 parse_Symbol(Tokens) ->
     parse_Reference(Tokens).
 
 parse_Reference([{typereference,L1,TrefName},{'{',_L2},{'}',_L3}|Rest]) ->
-%    {Tref,Rest};
     {tref2Exttref(L1,TrefName),Rest};
 parse_Reference([Tref1 = {typereference,_,_},{'.',_},Tref2 = {typereference,_,_},
 		 {'{',_L2},{'}',_L3}|Rest]) ->
-%    {{Tref1,Tref2},Rest};
     {{tref2Exttref(Tref1),tref2Exttref(Tref2)},Rest};
 parse_Reference([Tref = {typereference,_L1,_TrefName}|Rest]) ->
     {tref2Exttref(Tref),Rest};
-parse_Reference([Vref = {identifier,_L1,_VName},{'{',_L2},{'}',_L3}|Rest]) ->
+parse_Reference([#identifier{}=Vref,{'{',_L2},{'}',_L3}|Rest]) ->
     {identifier2Extvalueref(Vref),Rest};
-parse_Reference([Vref = {identifier,_L1,_VName}|Rest]) ->
+parse_Reference([#identifier{}=Vref|Rest]) ->
     {identifier2Extvalueref(Vref),Rest};
 parse_Reference(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			[typereference,identifier]]}}).
+    parse_error(Tokens).
 
 parse_Imports([{'IMPORTS',_L1},{';',_L2}|Rest]) ->
     {{imports,[]},Rest};
@@ -156,9 +174,8 @@ parse_Imports([{'IMPORTS',_L1}|Rest]) ->
     case Rest2 of
 	[{';',_L2}|Rest3] ->
 	    {{imports,SymbolsFromModuleList},Rest3};
-	Rest3 ->
-	    throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
-			       [got,get_token(hd(Rest3)),expected,';']}})
+	_ ->
+	    parse_error(Rest2)
     end;
 parse_Imports(Tokens) ->
     {{imports,[]},Tokens}.
@@ -168,11 +185,12 @@ parse_SymbolsFromModuleList(Tokens) ->
 
 parse_SymbolsFromModuleList(Tokens,Acc) ->
     {SymbolsFromModule,Rest} = parse_SymbolsFromModule(Tokens),
-    case (catch parse_SymbolsFromModule(Rest)) of 
+    try parse_SymbolsFromModule(Rest) of
 	{Sl,_Rest2} when is_record(Sl,'SymbolsFromModule') ->
-	    parse_SymbolsFromModuleList(Rest,[SymbolsFromModule|Acc]);
-	_  ->
-	    {lists:reverse([SymbolsFromModule|Acc]),Rest}
+	    parse_SymbolsFromModuleList(Rest, [SymbolsFromModule|Acc])
+    catch
+	throw:{asn1_error,_} ->
+	    {lists:reverse(Acc, [SymbolsFromModule]),Rest}
     end.
     
 parse_SymbolsFromModule(Tokens) ->
@@ -186,169 +204,154 @@ parse_SymbolsFromModule(Tokens) ->
 	end,
     {SymbolList,Rest} = parse_SymbolList(Tokens),
     case Rest of
-	[{'FROM',_L1},Tref = {typereference,_,Name},Ref={identifier,_L2,_Id},C={',',_}|Rest2] ->
-	    NewSymbolList = lists:map(SetRefModuleName(Name),SymbolList),
+	[{'FROM',_L1},{typereference,_,Name}=Tref|
+	 [#identifier{},{',',_}|_]=Rest2] ->
+	    NewSymbolList = lists:map(SetRefModuleName(Name), SymbolList),
 	    {#'SymbolsFromModule'{symbols=NewSymbolList,
-				  module=tref2Exttref(Tref)},[Ref,C|Rest2]};
+				  module=tref2Exttref(Tref)},Rest2};
 
 	%% This a special case when there is only one Symbol imported
 	%% from the next module. No other way to distinguish Ref from
 	%% a part of the GlobalModuleReference of Name.
-	[{'FROM',_L1},Tref = {typereference,_,Name},Ref = {identifier,_L2,_Id},From = {'FROM',_}|Rest2] ->
-	    NewSymbolList = lists:map(SetRefModuleName(Name),SymbolList),
+	[{'FROM',_L1},{typereference,_,Name}=Tref|
+	 [#identifier{},{'FROM',_}|_]=Rest2] ->
+	    NewSymbolList = lists:map(SetRefModuleName(Name), SymbolList),
 	    {#'SymbolsFromModule'{symbols=NewSymbolList,
-				  module=tref2Exttref(Tref)},[Ref,From|Rest2]};
-	[{'FROM',_L1},Tref = {typereference,_,Name},{identifier,_L2,_Id}|Rest2] ->
-	    NewSymbolList = lists:map(SetRefModuleName(Name),SymbolList),
+				  module=tref2Exttref(Tref)},Rest2};
+	[{'FROM',_L1},{typereference,_,Name}=Tref,#identifier{}|Rest2] ->
+	    NewSymbolList = lists:map(SetRefModuleName(Name), SymbolList),
 	    {#'SymbolsFromModule'{symbols=NewSymbolList,
 				  module=tref2Exttref(Tref)},Rest2}; 
-	[{'FROM',_L1},Tref = {typereference,_,Name},Brace = {'{',_}|Rest2] ->
-	    {_ObjIdVal,Rest3} = parse_ObjectIdentifierValue([Brace|Rest2]), % value not used yet, fix me
-	    NewSymbolList = lists:map(SetRefModuleName(Name),SymbolList),
+	[{'FROM',_L1},{typereference,_,Name}=Tref|[{'{',_}|_]=Rest2] ->
+	    {_ObjIdVal,Rest3} = parse_ObjectIdentifierValue(Rest2), % value not used yet, fix me
+	    NewSymbolList = lists:map(SetRefModuleName(Name), SymbolList),
 	    {#'SymbolsFromModule'{symbols=NewSymbolList,
 				  module=tref2Exttref(Tref)},Rest3}; 
-	[{'FROM',_L1},Tref = {typereference,_,Name}|Rest2] ->
-	    NewSymbolList = lists:map(SetRefModuleName(Name),SymbolList),
+	[{'FROM',_L1},{typereference,_,Name}=Tref|Rest2] ->
+	    NewSymbolList = lists:map(SetRefModuleName(Name), SymbolList),
 	    {#'SymbolsFromModule'{symbols=NewSymbolList,
 				  module=tref2Exttref(Tref)},Rest2};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
-			       [got,get_token(hd(Rest)),expected,
-				['FROM typerefernece identifier ,',
-				 'FROM typereference identifier',
-				 'FROM typereference {',
-				 'FROM typereference']]}})
+	    parse_error(Rest)
     end.
 
 parse_ObjectIdentifierValue([{'{',_}|Rest]) ->
     parse_ObjectIdentifierValue(Rest,[]).
 
-parse_ObjectIdentifierValue([{number,_,Num}|Rest],Acc) ->
+parse_ObjectIdentifierValue([{number,_,Num}|Rest], Acc) ->
     parse_ObjectIdentifierValue(Rest,[Num|Acc]);
-parse_ObjectIdentifierValue([{identifier,_,Id},{'(',_}, {number,_,Num}, {')',_}|Rest],Acc) ->
+parse_ObjectIdentifierValue([#identifier{val=Id},{'(',_},{number,_,Num},{')',_}|Rest], Acc) ->
     parse_ObjectIdentifierValue(Rest,[{'NamedNumber',Id,Num}|Acc]);
-parse_ObjectIdentifierValue([{identifier,_,Id},{'(',_}, {identifier,_,Id2}, {')',_}|Rest],Acc) ->
+parse_ObjectIdentifierValue([#identifier{val=Id},{'(',_},#identifier{val=Id2},{')',_}|Rest], Acc) ->
     parse_ObjectIdentifierValue(Rest,[{'NamedNumber',Id,Id2}|Acc]);
-parse_ObjectIdentifierValue([{identifier,_,Id},{'(',_}, {typereference,_,Tref},{'.',_},{identifier,_,Id2}, {')',_}|Rest],Acc) ->
-    parse_ObjectIdentifierValue(Rest,[{'NamedNumber',Id,{'ExternalValue',Tref,Id2}}|Acc]);
-parse_ObjectIdentifierValue([Id = {identifier,_,_}|Rest],Acc) ->
-    parse_ObjectIdentifierValue(Rest,[identifier2Extvalueref(Id)|Acc]);
-parse_ObjectIdentifierValue([{'}',_}|Rest],Acc) ->
+parse_ObjectIdentifierValue([#identifier{val=Id},{'(',_},{typereference,_,Tref},{'.',_},#identifier{val=Id2}, {')',_}|Rest], Acc) ->
+    parse_ObjectIdentifierValue(Rest, [{'NamedNumber',Id,{'ExternalValue',Tref,Id2}}|Acc]);
+parse_ObjectIdentifierValue([#identifier{}=Id|Rest], Acc) ->
+    parse_ObjectIdentifierValue(Rest, [identifier2Extvalueref(Id)|Acc]);
+parse_ObjectIdentifierValue([{'}',_}|Rest], Acc) ->
     {lists:reverse(Acc),Rest};
-parse_ObjectIdentifierValue([H|_T],_Acc) ->
-    throw({asn1_error,{get_line(H),get(asn1_module),
-		       [got,get_token(H),expected,
-			['{ some of the following }',number,'identifier ( number )',
-			 'identifier ( identifier )',
-			 'identifier ( typereference.identifier)',identifier]]}}).
+parse_ObjectIdentifierValue(Tokens, _Acc) ->
+    parse_error(Tokens).
     
-parse_AssignmentList(Tokens = [{'END',_}|_Rest]) ->
-    {[],Tokens};
-parse_AssignmentList(Tokens = [{'$end',_}|_Rest]) ->
-    {[],Tokens};
 parse_AssignmentList(Tokens) ->
-    parse_AssignmentList(Tokens,[]).
+    parse_AssignmentList(Tokens, []).
 
-parse_AssignmentList(Tokens= [{'END',_}|_Rest],Acc) ->
+parse_AssignmentList([{'END',_}|_]=Tokens, Acc) ->
     {lists:reverse(Acc),Tokens};
-parse_AssignmentList(Tokens= [{'$end',_}|_Rest],Acc) ->
+parse_AssignmentList([{'$end',_}|_]=Tokens, Acc) ->
     {lists:reverse(Acc),Tokens};
-parse_AssignmentList(Tokens,Acc) ->
-    case (catch parse_Assignment(Tokens)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	{asn1_error,R} ->
-%	    [H|T] = Tokens,
-	    throw({error,{R,hd(Tokens)}});
-	{Assignment,Rest} ->
-	    parse_AssignmentList(Rest,[Assignment|Acc])
-    end.
-
-parse_Assignment(Tokens) ->
-    Flist = [fun parse_TypeAssignment/1,
-	     fun parse_ValueAssignment/1,
-	     fun parse_ObjectClassAssignment/1,
-	     fun parse_ObjectAssignment/1,
-	     fun parse_ObjectSetAssignment/1,
-	     fun parse_ParameterizedAssignment/1,
+parse_AssignmentList(Tokens0, Acc) ->
+    {Assignment,Tokens} = parse_Assignment(Tokens0),
+    parse_AssignmentList(Tokens, [Assignment|Acc]).
+
+parse_Assignment([{typereference,L1,Name},{'::=',_}|Tokens0]) ->
+    %% 1) Type ::= TypeDefinition
+    %% 2) CLASS-NAME ::= CLASS {...}
+    Flist = [{type,fun parse_Type/1},
+	     {class,fun parse_ObjectClass/1}],
+    case parse_or_tag(Tokens0, Flist) of
+	{{type,Type},Tokens} ->
+	    %% TypeAssignment
+	    {#typedef{pos=L1,name=Name,typespec=Type},Tokens};
+	{{class,Type},Tokens} ->
+	    %% ObjectClassAssignment
+	    {#classdef{pos=L1,name=Name,module=resolve_module(Type),
+		       typespec=Type},Tokens}
+    end;
+parse_Assignment([{typereference,_,_},{'{',_}|_]=Tokens) ->
+    %% 1) Type{...} ::= ...
+    %% 2) ValueSet{...} Type ::= ...
+    %%    ObjectSet{...} CLASS-NAME ::= CLASS {...}
+    %% 3) CLASS-NAME{...} ::= CLASS {...}
+    %% A parameterized value set and and a parameterized object set
+    %% cannot be distinguished from each other without type information.
+    Flist = [fun parse_ParameterizedTypeAssignment/1,
+	     fun parse_ParameterizedValueSetTypeAssignment/1,
+	     fun parse_ParameterizedObjectClassAssignment/1],
+    parse_or(Tokens, Flist);
+parse_Assignment([{typereference,_,_}|_]=Tokens) ->
+    %% 1) ObjectSet CLASS-NAME ::= ...
+    %% 2) ValueSet Type ::= ...
+    Flist = [fun parse_ObjectSetAssignment/1,
 	     fun parse_ValueSetTypeAssignment/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	{asn1_assignment_error,Reason} ->
-	    throw({asn1_error,Reason});
-	Result ->
-	    Result
-    end.
-
+    parse_or(Tokens, Flist);
+parse_Assignment([#identifier{},{'{',_}|_]=Tokens) ->
+    %% 1) value{...} Type ::= ...
+    %% 2) object{...} CLASS-NAME ::= ...
+    Flist = [fun parse_ParameterizedValueAssignment/1,
+	     fun parse_ParameterizedObjectAssignment/1],
+    parse_or(Tokens, Flist);
+parse_Assignment([#identifier{}|_]=Tokens) ->
+    %% 1) value Type ::= ...
+    %% 2) object CLASS-NAME ::= ...
+    Flist = [fun parse_ValueAssignment/1,
+	     fun parse_ObjectAssignment/1],
+    parse_or(Tokens, Flist);
+parse_Assignment(Tokens) ->
+    parse_error(Tokens).
 
 parse_or(Tokens,Flist) ->
 	parse_or(Tokens,Flist,[]).
 
-parse_or(_Tokens,[],ErrList) ->
-    case ErrList of
-	[] ->
-	    throw({asn1_error,{parse_or,ErrList}});
-	L when is_list(L) ->
-	    %% chose to throw 1) the error with the highest line no,
-	    %% 2) the last error which is not a asn1_assignment_error or
-	    %% 3) the last error.
-	    throw(prioritize_error(ErrList))
+parse_or(Tokens, [Fun|Funs], ErrList) when is_function(Fun, 1) ->
+    try Fun(Tokens) of
+	{_,Rest}=Result when is_list(Rest) ->
+	    Result
+    catch
+	throw:{asn1_error,Error} ->
+	    parse_or(Tokens, Funs, [Error|ErrList])
     end;
-parse_or(Tokens,[Fun|Frest],ErrList) ->
-    case (catch Fun(Tokens)) of
-	Exit = {'EXIT',_Reason} ->
-	    parse_or(Tokens,Frest,[Exit|ErrList]);
-	AsnErr = {asn1_error,_} ->
-	    parse_or(Tokens,Frest,[AsnErr|ErrList]);
-	AsnAssErr = {asn1_assignment_error,_} ->
-	    parse_or(Tokens,Frest,[AsnAssErr|ErrList]);
-	Result = {_,L} when is_list(L) ->
-	    Result;
-	Error  ->
-	    parse_or(Tokens,Frest,[Error|ErrList])
-    end.
-
-parse_or_tag(Tokens,Flist) ->
-	parse_or_tag(Tokens,Flist,[]).
-
-parse_or_tag(_Tokens,[],ErrList) ->
-    case ErrList of
-	[] ->
-	    throw({asn1_error,{parse_or_tag,ErrList}});
-	L when is_list(L) ->
-	    %% chose to throw 1) the error with the highest line no,
-	    %% 2) the last error which is not a asn1_assignment_error or
-	    %% 3) the last error.
-	    throw(prioritize_error(ErrList))
+parse_or(_Tokens, [], ErrList) ->
+    throw({asn1_error,fun() -> prioritize_error(ErrList) end}).
+
+parse_or_tag(Tokens, Flist) ->
+    parse_or_tag(Tokens, Flist, []).
+
+parse_or_tag(Tokens, [{Tag,Fun}|Funs], ErrList) when is_function(Fun, 1) ->
+    try Fun(Tokens) of
+	{Parsed,Rest} when is_list(Rest) ->
+	    {{Tag,Parsed},Rest}
+    catch
+	throw:{asn1_error,Error} ->
+	    parse_or_tag(Tokens, Funs, [Error|ErrList])
     end;
-parse_or_tag(Tokens,[{Tag,Fun}|Frest],ErrList) when is_function(Fun) ->
-    case (catch Fun(Tokens)) of
-	Exit = {'EXIT',_Reason} ->
-	    parse_or_tag(Tokens,Frest,[Exit|ErrList]);
-	AsnErr = {asn1_error,_} ->
-	    parse_or_tag(Tokens,Frest,[AsnErr|ErrList]);
-	AsnAssErr = {asn1_assignment_error,_} ->
-	    parse_or_tag(Tokens,Frest,[AsnAssErr|ErrList]);
-	{ParseRes,Rest} when is_list(Rest) ->
-	    {{Tag,ParseRes},Rest};
-	Error  ->
-	    parse_or_tag(Tokens,Frest,[Error|ErrList])
-    end.
+parse_or_tag(_Tokens, [], ErrList) ->
+    throw({asn1_error,fun() -> prioritize_error(ErrList) end}).
+
+prioritize_error(Errors0) ->
+    Errors1 = prioritize_error_1(Errors0),
+    Errors2 = [{length(L),L} || L <- Errors1],
+    Errors = lists:sort(Errors2),
+    [Res|_] = [L || {_,L} <- Errors],
+    Res.
+
+prioritize_error_1([F|T]) when is_function(F, 0) ->
+    [F()|prioritize_error_1(T)];
+prioritize_error_1([{parse_error,Tokens}|T]) ->
+    [Tokens|prioritize_error_1(T)];
+prioritize_error_1([]) ->
+    [].
 
-parse_TypeAssignment([{typereference,L1,Tref},{'::=',_}|Rest]) ->	
-    {Type,Rest2} = parse_Type(Rest),
-    {#typedef{pos=L1,name=Tref,typespec=Type},Rest2};
-parse_TypeAssignment([H1,H2|_Rest]) ->
-    throw({asn1_assignment_error,{get_line(H1),get(asn1_module),
-				  [got,[get_token(H1),get_token(H2)], expected,
-				   typereference,'::=']}});
-parse_TypeAssignment([H|_T]) ->
-    throw({asn1_assignment_error,{get_line(H),get(asn1_module),
-				  [got,get_token(H),expected,
-				   typereference]}}).
 
 %% parse_Type(Tokens) -> Ret
 %%
@@ -358,9 +361,8 @@ parse_TypeAssignment([H|_T]) ->
 %%
 parse_Type(Tokens) ->
     {Tag,Rest3} = case Tokens of
-		      [Lbr= {'[',_}|Rest] ->
-			  parse_Tag([Lbr|Rest]);
-		      Rest-> {[],Rest}
+		      [{'[',_}|_] -> parse_Tag(Tokens);
+		      _ -> {[],Tokens}
 		  end,
     {Tag2,Rest4} = case Rest3 of
 		       [{'IMPLICIT',_}|Rest31] when is_record(Tag,tag)->
@@ -372,31 +374,17 @@ parse_Type(Tokens) ->
 		       Rest31 ->
 			   {Tag,Rest31}
 		   end,
-    Flist = [fun parse_BuiltinType/1,fun parse_ReferencedType/1,fun parse_TypeWithConstraint/1],
-    {Type,Rest5} = case (catch parse_or(Rest4,Flist)) of
-		      {'EXIT',Reason} ->
-			  exit(Reason);
-			AsnErr = {asn1_error,_Reason} ->
-			 throw(AsnErr);
-		      Result ->
-			  Result
-		  end,
-    case hd(Rest5) of
-	{'(',_} ->
+    Flist = [fun parse_BuiltinType/1,
+	     fun parse_ReferencedType/1,
+	     fun parse_TypeWithConstraint/1],
+    {Type,Rest5} = parse_or(Rest4, Flist),
+    case Rest5 of
+	[{'(',_}|_] ->
 	    {Constraints,Rest6} = parse_Constraints(Rest5),
-	    if is_record(Type,type) ->
-		    {Type#type{constraint=merge_constraints(Constraints),
-			       tag=Tag2},Rest6};
-	       true ->
-		    {#type{def=Type,constraint=merge_constraints(Constraints),
-			   tag=Tag2},Rest6}
-	    end;
-	_ ->
-	    if is_record(Type,type) ->
-		    {Type#type{tag=Tag2},Rest5};
-	       true ->
-		    {#type{def=Type,tag=Tag2},Rest5}
-	    end
+	    {Type#type{tag=Tag2,
+		       constraint=merge_constraints(Constraints)},Rest6};
+	[_|_] ->
+	    {Type#type{tag=Tag2},Rest5}
     end.
 
 parse_BuiltinType([{'BIT',_},{'STRING',_}|Rest]) ->
@@ -407,11 +395,10 @@ parse_BuiltinType([{'BIT',_},{'STRING',_}|Rest]) ->
 		[{'}',_}|Rest4] ->
 		    {#type{def={'BIT STRING',NamedNumberList}},Rest4};
 		_ ->
-		    throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
-				       [got,get_token(hd(Rest3)),expected,'}']}})
+		    parse_error(Rest3)
 	    end;
 	 _ ->
-	    {{'BIT STRING',[]},Rest}
+	    {#type{def={'BIT STRING',[]}},Rest}
     end;
 parse_BuiltinType([{'BOOLEAN',_}|Rest]) ->
     {#type{def='BOOLEAN'},Rest};
@@ -423,41 +410,33 @@ parse_BuiltinType([{'CHARACTER',_},{'STRING',_}|Rest]) ->
     {#type{def='CHARACTER STRING'},Rest};
 
 parse_BuiltinType([{'CHOICE',_},{'{',_}|Rest]) ->
-    {AlternativeTypeLists,Rest2} = parse_AlternativeTypeLists(Rest),
-    AlternativeTypeLists1 =
-	lists:filter(fun(#'ExtensionAdditionGroup'{}) -> false;
-			('ExtensionAdditionGroupEnd') -> false;
-			(_) -> true
-		     end,AlternativeTypeLists),
+    {L0,Rest2} = parse_AlternativeTypeLists(Rest),
     case Rest2 of
 	[{'}',_}|Rest3] ->
-	    AlternativeTypeLists2 =
-		case {[Ext||Ext = #'EXTENSIONMARK'{} <- AlternativeTypeLists1],
-		      get(extensiondefault)} of
-		    {[],'IMPLIED'} ->  AlternativeTypeLists1 ++ [#'EXTENSIONMARK'{}];
-		    _ -> AlternativeTypeLists1
+	    NeedExt = not lists:keymember('EXTENSIONMARK', 1, L0) andalso
+		get(extensiondefault) =:= 'IMPLIED',
+	    L = case NeedExt of
+		    true ->
+			L0 ++ [#'EXTENSIONMARK'{}];
+		    false ->
+			L0
 		end,
-
-	    {#type{def={'CHOICE',AlternativeTypeLists2}},Rest3};
+	    {#type{def={'CHOICE',L}},Rest3};
 	_  ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,'}']}})
+	    parse_error(Rest2)
     end;
 parse_BuiltinType([{'EMBEDDED',_},{'PDV',_}|Rest]) ->
     {#type{def='EMBEDDED PDV'},Rest};
 parse_BuiltinType([{'ENUMERATED',_},{'{',_}|Rest]) ->
-    {Enumerations,Rest2} = parse_Enumerations(Rest,get(extensiondefault)),
+    {Enumerations,Rest2} = parse_Enumerations(Rest),
     case Rest2 of
 	[{'}',_}|Rest3] ->
 	    {#type{def={'ENUMERATED',Enumerations}},Rest3};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,'}']}})
+	    parse_error(Rest2)
     end;
 parse_BuiltinType([{'EXTERNAL',_}|Rest]) ->
     {#type{def='EXTERNAL'},Rest};
-
-% InstanceOfType
 parse_BuiltinType([{'INSTANCE',_},{'OF',_}|Rest]) ->
     {DefinedObjectClass,Rest2} = parse_DefinedObjectClass(Rest),
     case Rest2 of
@@ -468,9 +447,6 @@ parse_BuiltinType([{'INSTANCE',_},{'OF',_}|Rest]) ->
 	_ ->
 	    {#type{def={'INSTANCE OF',DefinedObjectClass,[]}},Rest2}
     end;
-
-% parse_BuiltinType(Tokens) ->
-    
 parse_BuiltinType([{'INTEGER',_}|Rest]) ->
     case Rest of 
 	[{'{',_}|Rest2] ->
@@ -479,17 +455,13 @@ parse_BuiltinType([{'INTEGER',_}|Rest]) ->
 		[{'}',_}|Rest4] ->
 		    {#type{def={'INTEGER',NamedNumberList}},Rest4};
 		_ ->
-		    throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
-				       [got,get_token(hd(Rest3)),expected,'}']}})
+		    parse_error(Rest3)
 	    end;
 	 _ ->
 	    {#type{def='INTEGER'},Rest}
     end;
 parse_BuiltinType([{'NULL',_}|Rest]) ->
     {#type{def='NULL'},Rest};
-
-% ObjectClassFieldType fix me later
-
 parse_BuiltinType([{'OBJECT',_},{'IDENTIFIER',_}|Rest]) ->
     {#type{def='OBJECT IDENTIFIER'},Rest};
 parse_BuiltinType([{'OCTET',_},{'STRING',_}|Rest]) ->
@@ -517,18 +489,14 @@ parse_BuiltinType([{'SEQUENCE',_},{'{',_},{'...',Line},{'!',_}|Rest]) ->
 		parse_ComponentTypeLists2(Rest2,[#'EXTENSIONMARK'{pos=Line}]),
 	    case Rest3 of
 		[{'}',_}|Rest4] ->
-	    {#type{def=#'SEQUENCE'{components=ComponentTypeLists}},Rest4};
+		    {#type{def=#'SEQUENCE'{components=ComponentTypeLists}},Rest4};
 		_  ->
-		    throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
-			       [got,get_token(hd(Rest3)),expected,'}']}})
+		    parse_error(Rest3)
 	    end
-% 	_ -> % Seq case 4,17-19,23-26 will fail here
-% 	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-% 			       [got,get_token(hd(Rest2)),expected,'}']}})
     end;
 parse_BuiltinType([{'SEQUENCE',_},{'{',_}|Rest]) ->
     {ComponentTypeLists,Rest2} = parse_ComponentTypeLists(Rest),
-    case Rest2  of
+    case Rest2 of
 	[{'}',_}|Rest3] ->
 	    ComponentTypeLists2 =
 		case {[Ext||Ext = #'EXTENSIONMARK'{} <- ComponentTypeLists],
@@ -539,25 +507,19 @@ parse_BuiltinType([{'SEQUENCE',_},{'{',_}|Rest]) ->
 	    {#type{def=#'SEQUENCE'{components = ComponentTypeLists2}},
 	     Rest3};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,'}']}})
+	    parse_error(Rest2)
     end;
-
-parse_BuiltinType([{'SEQUENCE',_},{'OF',_},Id={identifier,_,_},Lt={'<',_}|Rest]) ->
-%% TODO: take care of the identifier for something useful
-    {Type,Rest2} = parse_SelectionType([Id,Lt|Rest]),
-    {#type{def={'SEQUENCE OF',#type{def=Type,tag=[]}}},Rest2};
-
-parse_BuiltinType([{'SEQUENCE',_},{'OF',_},{identifier,_,_} |Rest]) ->
+parse_BuiltinType([{'SEQUENCE',_},{'OF',_}|
+		   [#identifier{},{'<',_}|_]=Tokens0]) ->
+    {Type,Tokens} = parse_SelectionType(Tokens0),
+    {#type{def={'SEQUENCE OF',Type}},Tokens};
+parse_BuiltinType([{'SEQUENCE',_},{'OF',_},#identifier{} |Rest]) ->
 %% TODO: take care of the identifier for something useful
     {Type,Rest2} = parse_Type(Rest),
     {#type{def={'SEQUENCE OF',Type}},Rest2};
-
 parse_BuiltinType([{'SEQUENCE',_},{'OF',_}|Rest]) ->
     {Type,Rest2} = parse_Type(Rest),
     {#type{def={'SEQUENCE OF',Type}},Rest2};
-
-
 parse_BuiltinType([{'SET',_},{'{',_},{'...',Line},{'}',_}|Rest]) ->
     {#type{def=#'SET'{components=[#'EXTENSIONMARK'{pos = Line}]}},Rest};
 parse_BuiltinType([{'SET',_},{'{',_},{'...',Line},{'!',_}|Rest]) ->
@@ -569,12 +531,18 @@ parse_BuiltinType([{'SET',_},{'{',_},{'...',Line},{'!',_}|Rest]) ->
 						val = ExceptionIdentification}]}},
 	     Rest3};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,'}']}})
+	    {ComponentTypeLists,Rest3}=
+		parse_ComponentTypeLists2(Rest2,[#'EXTENSIONMARK'{pos=Line}]),
+	    case Rest3 of
+		[{'}',_}|Rest4] ->
+		    {#type{def=#'SET'{components=ComponentTypeLists}},Rest4};
+		_  ->
+		    parse_error(Rest3)
+	    end
     end;
 parse_BuiltinType([{'SET',_},{'{',_}|Rest]) ->
     {ComponentTypeLists,Rest2} = parse_ComponentTypeLists(Rest),
-    case Rest2  of
+    case Rest2 of
 	[{'}',_}|Rest3] ->
 	    ComponentTypeLists2 =
 		case {[Ext||Ext = #'EXTENSIONMARK'{} <- ComponentTypeLists],
@@ -585,184 +553,128 @@ parse_BuiltinType([{'SET',_},{'{',_}|Rest]) ->
 	    {#type{def=#'SET'{components = ComponentTypeLists2}},
 	     Rest3};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,'}']}})
+	    parse_error(Rest2)
     end;
-
-parse_BuiltinType([{'SET',_},{'OF',_},Id={identifier,_,_},Lt={'<',_}|Rest]) ->
-%% TODO: take care of the identifier for something useful
-    {Type,Rest2} = parse_SelectionType([Id,Lt|Rest]),
-    {#type{def={'SET OF',#type{def=Type,tag=[]}}},Rest2};
-
-
-parse_BuiltinType([{'SET',_},{'OF',_},{identifier,_,_}|Rest]) ->
+parse_BuiltinType([{'SET',_},{'OF',_}|
+		   [#identifier{},{'<',_}|_]=Tokens0]) ->
+    {Type,Tokens} = parse_SelectionType(Tokens0),
+    {#type{def={'SET OF',Type}},Tokens};
+parse_BuiltinType([{'SET',_},{'OF',_},#identifier{}|Rest]) ->
 %%TODO: take care of the identifier for something useful
     {Type,Rest2} = parse_Type(Rest),
     {#type{def={'SET OF',Type}},Rest2};
-
 parse_BuiltinType([{'SET',_},{'OF',_}|Rest]) ->
     {Type,Rest2} = parse_Type(Rest),
     {#type{def={'SET OF',Type}},Rest2};
-
-%% The so called Useful types
 parse_BuiltinType([{'GeneralizedTime',_}|Rest]) ->
     {#type{def='GeneralizedTime'},Rest};
 parse_BuiltinType([{'UTCTime',_}|Rest]) ->
     {#type{def='UTCTime'},Rest};
 parse_BuiltinType([{'ObjectDescriptor',_}|Rest]) ->
     {#type{def='ObjectDescriptor'},Rest};
-
-%% For compatibility with old standard
-parse_BuiltinType([{'ANY',_},{'DEFINED',_},{'BY',_},{identifier,_,Id}|Rest]) ->
+parse_BuiltinType([{'ANY',_},{'DEFINED',_},{'BY',_},#identifier{val=Id}|Rest]) ->
+    %% For compatibility with the old standard.
     {#type{def={'ANY_DEFINED_BY',Id}},Rest};
 parse_BuiltinType([{'ANY',_}|Rest]) ->
+    %% For compatibility with the old standard.
     {#type{def='ANY'},Rest};
-
 parse_BuiltinType(Tokens) ->
     parse_ObjectClassFieldType(Tokens).
-%    throw({asn1_error,unhandled_type}).
 
 
-parse_TypeWithConstraint([{'SEQUENCE',_},Lpar = {'(',_}|Rest]) ->
-    {Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
+parse_TypeWithConstraint([{'SEQUENCE',_}|[{'(',_}|_]=Rest0]) ->
+    {Constraint,Rest2} = parse_Constraint(Rest0),
     Rest4 = case Rest2 of
-		[{'OF',_}, {identifier,_,_Id}|Rest3] ->
+		[{'OF',_},#identifier{}|Rest3] ->
 %%% TODO: make some use of the identifier, maybe useful in the XML mapping
 		    Rest3;
 		[{'OF',_}|Rest3] ->
 		    Rest3;
 		_ ->
-		    throw({asn1_error,
-			   {get_line(hd(Rest2)),get(asn1_module),
-			    [got,get_token(hd(Rest2)),expected,'OF']}})
+		    parse_error(Rest2)
 	    end,
     {Type,Rest5} = parse_Type(Rest4),
     {#type{def = {'SEQUENCE OF',Type},
 	   constraint = merge_constraints([Constraint])},Rest5};
 
-parse_TypeWithConstraint([{'SEQUENCE',_},{'SIZE',_},Lpar = {'(',_}|Rest]) ->
-    {Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
+parse_TypeWithConstraint([{'SEQUENCE',_},{'SIZE',_}|[{'(',_}|_]=Rest0]) ->
+    {Constraint,Rest2} = parse_Constraint(Rest0),
     #constraint{c=C} = Constraint,
-    Constraint2 = Constraint#constraint{c={'SizeConstraint',C}},
+    Constraint2 = Constraint#constraint{c={element_set,{'SizeConstraint',C},
+					   none}},
     Rest4 = case Rest2 of
-		[{'OF',_}, {identifier,_,_Id}|Rest3] ->
+		[{'OF',_},#identifier{}|Rest3] ->
 %%% TODO: make some use of the identifier, maybe useful in the XML mapping
 		    Rest3;
 		[{'OF',_}|Rest3] ->
 		    Rest3;
 		_ ->
-		    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-				       [got,get_token(hd(Rest2)),expected,'OF']}})
+		    parse_error(Rest2)
 	    end,
     {Type,Rest5} = parse_Type(Rest4),
     {#type{def = {'SEQUENCE OF',Type}, constraint = merge_constraints([Constraint2])},Rest5};
 
-parse_TypeWithConstraint([{'SET',_},Lpar = {'(',_}|Rest]) ->
-    {Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
+parse_TypeWithConstraint([{'SET',_}|[{'(',_}|_]=Rest0]) ->
+    {Constraint,Rest2} = parse_Constraint(Rest0),
     Rest4 = case Rest2 of
-		[{'OF',_}, {identifier,_,_Id}|Rest3] ->
+		[{'OF',_},#identifier{}|Rest3] ->
 %%% TODO: make some use of the identifier, maybe useful in the XML mapping
 		    Rest3;
 		[{'OF',_}|Rest3] ->
 		    Rest3;
 		_ ->
-		    throw({asn1_error,
-			   {get_line(hd(Rest2)),get(asn1_module),
-			    [got,get_token(hd(Rest2)),expected,'OF']}})
+		    parse_error(Rest2)
 	    end,
     {Type,Rest5} = parse_Type(Rest4),
     {#type{def = {'SET OF',Type},
 	   constraint = merge_constraints([Constraint])},Rest5};
 
-parse_TypeWithConstraint([{'SET',_},{'SIZE',_},Lpar = {'(',_}|Rest]) ->
-    {Constraint,Rest2} = parse_Constraint([Lpar|Rest]),
+parse_TypeWithConstraint([{'SET',_},{'SIZE',_}|[{'(',_}|_]=Rest0]) ->
+    {Constraint,Rest2} = parse_Constraint(Rest0),
     #constraint{c=C} = Constraint,
-    Constraint2 = Constraint#constraint{c={'SizeConstraint',C}},
+    Constraint2 = Constraint#constraint{c={element_set,
+					   {'SizeConstraint',C},none}},
     Rest4 = case Rest2 of
-		[{'OF',_}, {identifier,_,_Id}|Rest3] ->
+		[{'OF',_},#identifier{}|Rest3] ->
 %%% TODO: make some use of the identifier, maybe useful in the XML mapping
 		    Rest3;
 		[{'OF',_}|Rest3] ->
 		    Rest3;
 		_ ->
-		    throw({asn1_error,
-			   {get_line(hd(Rest2)),get(asn1_module),
-			    [got,get_token(hd(Rest2)),expected,'OF']}})
+		    parse_error(Rest2)
 	    end,
     {Type,Rest5} = parse_Type(Rest4),
     {#type{def = {'SET OF',Type},
 	   constraint = merge_constraints([Constraint2])},Rest5};
 
 parse_TypeWithConstraint(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-		       ['SEQUENCE','SEQUENCE SIZE','SET','SET SIZE'],
-		       followed,by,a,constraint]}}).
+    parse_error(Tokens).
 
 
 %% --------------------------
 
 parse_ReferencedType(Tokens) ->
-    Flist = [fun parse_DefinedType/1,
+    Flist = [fun parse_ParameterizedType/1,
+	     fun parse_DefinedType/1,
 	     fun parse_SelectionType/1,
-	     fun parse_TypeFromObject/1,
-	     fun parse_ValueSetFromObjects/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+	     fun parse_TypeFromObject/1],
+    parse_or(Tokens, Flist).
     
-parse_DefinedType(Tokens=[{typereference,_,_},{'{',_}|_Rest]) ->
-    parse_ParameterizedType(Tokens);
-parse_DefinedType(Tokens=[{typereference,L1,TypeName},
-			  T2={typereference,_,_},T3={'{',_}|Rest]) ->
-    case (catch parse_ParameterizedType(Tokens)) of
-	{'EXIT',_Reason} ->
-	    Rest2 = [T2,T3|Rest],
-	    {#type{def = #'Externaltypereference'{pos=L1,
-						  module=resolve_module(TypeName),
-						  type=TypeName}},Rest2};
-	{asn1_error,_} ->
-	    Rest2 = [T2,T3|Rest],
-	    {#type{def = #'Externaltypereference'{pos=L1,
-						  module=resolve_module(TypeName),
-						  type=TypeName}},Rest2};
-	Result ->
-	    Result
-    end;
-parse_DefinedType(Tokens=[{typereference,_L1,_Module},{'.',_},
-			  {typereference,_,_TypeName},{'{',_}|_Rest]) ->
-    parse_ParameterizedType(Tokens);
-parse_DefinedType([{typereference,L1,Module},{'.',_},{typereference,_,TypeName}|Rest]) ->
-    {#type{def = #'Externaltypereference'{pos=L1,module=Module,type=TypeName}},Rest};
-parse_DefinedType([{typereference,L1,TypeName}|Rest]) ->
-    case is_pre_defined_class(TypeName) of
-	false  ->
-	    {#type{def = #'Externaltypereference'{pos=L1,module=resolve_module(TypeName),
-						  type=TypeName}},Rest};
-	_ ->
-	    throw({asn1_error,
-		   {L1,get(asn1_module),
-		    [got,TypeName,expected,
-		     [typereference,'typereference.typereference',
-		      'typereference typereference']]}})
-    end;
+parse_DefinedType([{typereference,L1,Module},
+		   {'.',_},
+		   {typereference,_,TypeName}|Tokens]) ->
+    {#type{def = #'Externaltypereference'{pos=L1,module=Module,
+					  type=TypeName}},Tokens};
+parse_DefinedType([{typereference,_,_}=Tr|Tokens]) ->
+    {#type{def=tref2Exttref(Tr)},Tokens};
 parse_DefinedType(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			[typereference,'typereference.typereference',
-			 'typereference typereference']]}}).
+    parse_error(Tokens).
 
-parse_SelectionType([{identifier,_,Name},{'<',_}|Rest]) ->    
+parse_SelectionType([#identifier{val=Name},{'<',_}|Rest]) ->
     {Type,Rest2} = parse_Type(Rest),
-    {{'SelectionType',Name,Type},Rest2};
+    {#type{def={'SelectionType',Name,Type}},Rest2};
 parse_SelectionType(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'identifier <']}}).
+    parse_error(Tokens).
     
 
 resolve_module(Type) ->
@@ -775,30 +687,13 @@ resolve_module(_Type, Current, undefined) ->
 resolve_module(Type, Current, Imports) ->
     case [Mod || #'SymbolsFromModule'{symbols = S, module = Mod} <- Imports,
                  #'Externaltypereference'{type = T} <- S, 
-                 Type == T] of
+                 Type =:= T] of
         [#'Externaltypereference'{type = Mod}|_] -> Mod; 
 	%% This allows the same symbol to be imported several times
 	%% which ought to be checked elsewhere and flagged as an error
         []  -> Current
     end.
 
-%% --------------------------
-
-
-%% This should probably be removed very soon 
-% parse_ConstrainedType(Tokens) ->
-%     case (catch parse_TypeWithConstraint(Tokens)) of
-% 	{'EXIT',Reason} ->
-% 	    {Type,Rest} = parse_Type(Tokens),
-% 	    {Constraint,Rest2} = parse_Constraint(Rest),
-% 	    {Type#type{constraint=Constraint},Rest2};
-% 	{asn1_error,Reason2} ->
-% 	    {Type,Rest} = parse_Type(Tokens),
-% 	    {Constraint,Rest2} = parse_Constraint(Rest),
-% 	    {Type#type{constraint=Constraint},Rest2};
-% 	Result ->
-% 	    Result
-%     end.
 
 parse_Constraints(Tokens) ->
     parse_Constraints(Tokens,[]).
@@ -807,9 +702,9 @@ parse_Constraints(Tokens,Acc) ->
     {Constraint,Rest} = parse_Constraint(Tokens),
     case Rest of
 	[{'(',_}|_Rest2] ->
-	    parse_Constraints(Rest,[Constraint|Acc]);
+	    parse_Constraints(Rest, [Constraint|Acc]);
 	_ ->
-	    {lists:reverse([Constraint|Acc]),Rest}
+	    {lists:reverse(Acc, [Constraint]),Rest}
     end.
 
 parse_Constraint([{'(',_}|Rest]) ->
@@ -818,46 +713,27 @@ parse_Constraint([{'(',_}|Rest]) ->
     case Rest3 of
 	[{')',_}|Rest4] ->
 	    {#constraint{c=Constraint,e=Exception},Rest4};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,')']}})
-    end;
-parse_Constraint(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'(']}}).
+	[_|_] ->
+	    parse_error(Rest3)
+    end.
 
 parse_ConstraintSpec(Tokens) ->
     Flist = [fun parse_GeneralConstraint/1,
 	     fun parse_SubtypeConstraint/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	{asn1_error,Reason2} ->
-	    throw({asn1_error,Reason2});
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_ExceptionSpec([LPar={')',_}|Rest]) ->
     {undefined,[LPar|Rest]};
 parse_ExceptionSpec([{'!',_}|Rest]) ->
     parse_ExceptionIdentification(Rest);
 parse_ExceptionSpec(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,[')','!']]}}).
+    parse_error(Tokens).
 
 parse_ExceptionIdentification(Tokens) ->
     Flist = [fun parse_SignedNumber/1,
 	     fun parse_DefinedValue/1,
 	     fun parse_TypeColonValue/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	{asn1_error,Reason2} ->
-	    throw({asn1_error,Reason2});
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_TypeColonValue(Tokens) ->
     {Type,Rest} = parse_Type(Tokens),
@@ -865,32 +741,28 @@ parse_TypeColonValue(Tokens) ->
 	[{':',_}|Rest2] ->
 	    {Value,Rest3} = parse_Value(Rest2),
 	    {{Type,Value},Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,':']}})
+	[_|_] ->
+	    parse_error(Rest)
     end.
 
 parse_SubtypeConstraint(Tokens) ->
     parse_ElementSetSpecs(Tokens).
 
-parse_ElementSetSpecs([{'...',_}|Rest]) ->
-    {Elements,Rest2} = parse_ElementSetSpec(Rest),
-    {{[],Elements},Rest2};
 parse_ElementSetSpecs(Tokens) ->
     {RootElems,Rest} = parse_ElementSetSpec(Tokens),
     case Rest of
 	[{',',_},{'...',_},{',',_}|Rest2] ->
 	    {AdditionalElems,Rest3} = parse_ElementSetSpec(Rest2),
-	    {{RootElems,AdditionalElems},Rest3};
+	    {{element_set,RootElems,AdditionalElems},Rest3};
 	[{',',_},{'...',_}|Rest2] ->
-	    {{RootElems,[]},Rest2};
+	    {{element_set,RootElems,empty},Rest2};
 	_ ->
-	    {RootElems,Rest}
+	    {{element_set,RootElems,none},Rest}
     end.
 
 parse_ElementSetSpec([{'ALL',_},{'EXCEPT',_}|Rest]) ->
     {Exclusions,Rest2} = parse_Elements(Rest),
-    {{'ALL',{'EXCEPT',Exclusions}},Rest2};
+    {{'ALL-EXCEPT',Exclusions},Rest2};
 parse_ElementSetSpec(Tokens) ->
     parse_Unions(Tokens).
 
@@ -906,14 +778,8 @@ parse_Unions(Tokens) ->
     case {InterSec,Unions} of
 	{InterSec,[]} ->
 	    {InterSec,Rest2};
-	{{'SingleValue',V1},{'SingleValue',V2}} ->
-	    {{'SingleValue',ordsets:union(to_set(V1),to_set(V2))},Rest2};
-	{V1,V2} when is_list(V2) ->
-	    {[V1] ++ [union|V2],Rest2};
 	{V1,V2} ->
-	    {[V1,union,V2],Rest2}
-%	Other ->
-%	    throw(Other)
+	    {{union,V1,V2},Rest2}
     end.
 
 parse_UnionsRec([{'|',_}|Rest]) ->
@@ -922,12 +788,8 @@ parse_UnionsRec([{'|',_}|Rest]) ->
     case {InterSec,URec} of
 	{V1,[]} ->
 	    {V1,Rest3};
-	{{'SingleValue',V1},{'SingleValue',V2}} ->
-	    {{'SingleValue',ordsets:union(to_set(V1),to_set(V2))},Rest3};
-	{V1,V2} when is_list(V2) ->
-	    {[V1] ++ [union|V2],Rest3};
 	{V1,V2} ->
-	    {[V1,union,V2],Rest3}
+	    {{union,V1,V2},Rest3}
 	end;
 parse_UnionsRec([{'UNION',Info}|Rest]) ->
     parse_UnionsRec([{'|',Info}|Rest]);
@@ -940,13 +802,8 @@ parse_Intersections(Tokens) ->
     case {InterSec,IRec} of
 	{V1,[]} ->
 	    {V1,Rest2};
-	{{'SingleValue',V1},{'SingleValue',V2}} ->
-	    {{'SingleValue',
-	      ordsets:intersection(to_set(V1),to_set(V2))},Rest2};
-	{V1,V2} when is_list(V2) ->
-	    {[V1] ++ [intersection|V2],Rest2};
 	{V1,V2} ->
-	    {[V1,intersection,V2],Rest2}
+	    {{intersection,V1,V2},Rest2}
     end.
 
 %% parse_IElemsRec(Tokens) -> Result
@@ -955,15 +812,10 @@ parse_IElemsRec([{'^',_}|Rest]) ->
     {InterSec,Rest2} = parse_IntersectionElements(Rest),
     {IRec,Rest3} = parse_IElemsRec(Rest2),
     case {InterSec,IRec} of
-	{{'SingleValue',V1},{'SingleValue',V2}} ->
-	    {{'SingleValue',
-	      ordsets:intersection(to_set(V1),to_set(V2))},Rest3};
 	{V1,[]} ->
-	    {V1,Rest3};
-	{V1,V2} when is_list(V2) ->
-	    {[V1] ++ [intersection|V2],Rest3};
+	    {V1,Rest2};
 	{V1,V2} ->
-	    {[V1,intersection,V2],Rest3}
+	    {{intersection,V1,V2},Rest3}
     end;
 parse_IElemsRec([{'INTERSECTION',Info}|Rest]) ->
     parse_IElemsRec([{'^',Info}|Rest]);
@@ -980,7 +832,7 @@ parse_IntersectionElements(Tokens) ->
     case Rest of
 	[{'EXCEPT',_}|Rest2] ->
 	    {Exclusion,Rest3} = parse_Elements(Rest2),
-	    {{InterSec,{'EXCEPT',Exclusion}},Rest3};
+	    {{'EXCEPT',InterSec,Exclusion},Rest3};
 	Rest ->
 	    {InterSec,Rest}
     end.
@@ -994,105 +846,73 @@ parse_Elements([{'(',_}|Rest]) ->
     case Rest2 of
 	[{')',_}|Rest3] ->
 	    {Elems,Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,')']}})
+	[_|_] ->
+	    parse_error(Rest2)
     end;
 parse_Elements(Tokens) ->
     Flist = [fun parse_ObjectSetElements/1,
 	     fun parse_SubtypeElements/1,
-%	     fun parse_Value/1,
-%	     fun parse_Type/1,
 	     fun parse_Object/1,
 	     fun parse_DefinedObjectSet/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	Err = {asn1_error,_} ->
-	    throw(Err);
-	Result = {Val,_} when is_record(Val,type) ->
-	    Result;
-
-	Result ->
-	    Result
-    end.
-    
-
+    parse_or(Tokens, Flist).
     
 
 %% --------------------------
 
-parse_DefinedObjectClass([{typereference,_,_ModName},{'.',_},Tr={typereference,_,_ObjClName}|Rest]) ->
-%%    {{objectclassname,ModName,ObjClName},Rest};
-%    {{objectclassname,tref2Exttref(Tr)},Rest};
-    {tref2Exttref(Tr),Rest};
+parse_DefinedObjectClass([{typereference,_,ModName},{'.',_},
+			  {typereference,Pos,Name}|Tokens]) ->
+    Ext = #'Externaltypereference'{pos=Pos,
+				   module=ModName,
+				   type=Name},
+    {Ext,Tokens};
 parse_DefinedObjectClass([Tr={typereference,_,_ObjClName}|Rest]) ->
-%    {{objectclassname,tref2Exttref(Tr)},Rest};
     {tref2Exttref(Tr),Rest};
-parse_DefinedObjectClass([{'TYPE-IDENTIFIER',_}|Rest]) ->
-    {'TYPE-IDENTIFIER',Rest};
-parse_DefinedObjectClass([{'ABSTRACT-SYNTAX',_}|Rest]) ->
-    {'ABSTRACT-SYNTAX',Rest};
 parse_DefinedObjectClass(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			['typereference . typereference',
-			 typereference,
-			 'TYPE-IDENTIFIER',
-			 'ABSTRACT-SYNTAX']]}}).
-
-parse_ObjectClassAssignment([{typereference,L1,ObjClName},{'::=',_}|Rest]) ->
-    {Type,Rest2} = parse_ObjectClass(Rest),
-    {#classdef{pos=L1,name=ObjClName,typespec=Type},Rest2};
-parse_ObjectClassAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,
-				   'typereference ::=']}}).
+    parse_error(Tokens).
 
 parse_ObjectClass(Tokens) ->
-    Flist = [fun parse_DefinedObjectClass/1,
-	     fun parse_ObjectClassDefn/1,
-	     fun parse_ParameterizedObjectClass/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	{asn1_error,Reason2} ->
-	    throw({asn1_error,Reason2});
-	Result ->
-	    Result
-    end.
+    Flist = [fun parse_ObjectClassDefn/1,
+	     fun parse_DefinedObjectClass/1],
+    parse_or(Tokens, Flist).
 
 parse_ObjectClassDefn([{'CLASS',_},{'{',_}|Rest]) ->
     {Type,Rest2} = parse_FieldSpec(Rest),
     {WithSyntaxSpec,Rest3} = parse_WithSyntaxSpec(Rest2),
     {#objectclass{fields=Type,syntax=WithSyntaxSpec},Rest3};
 parse_ObjectClassDefn(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'CLASS {']}}).
+    parse_error(Tokens).
 
 parse_FieldSpec(Tokens) ->
     parse_FieldSpec(Tokens,[]).
 
-parse_FieldSpec(Tokens,Acc) ->
-    Flist = [fun parse_FixedTypeValueFieldSpec/1,
-	     fun parse_VariableTypeValueFieldSpec/1,
-	     fun parse_ObjectFieldSpec/1,
-	     fun parse_FixedTypeValueSetFieldSpec/1,
-	     fun parse_VariableTypeValueSetFieldSpec/1,
-	     fun parse_TypeFieldSpec/1,
-	     fun parse_ObjectSetFieldSpec/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
+parse_FieldSpec(Tokens0, Acc) ->
+    Fl = case Tokens0 of
+	     [{valuefieldreference,_,_}|_] ->
+		 %% 1) &field Type
+		 %%    &object CLASS-NAME
+		 %% 2) &field &FieldName
+		 %% A fixed type field cannot be distinguished from
+		 %% an object field without type information.
+		 [fun parse_FixedTypeValueFieldSpec/1,
+		  fun parse_VariableTypeValueFieldSpec/1];
+	     [{typefieldreference,_,_}|_] ->
+		 %% 1) &Set Type
+		 %%    &ObjectSet CLASS-NAME
+		 %% 2) &Set &FieldName
+		 %% 3) &Type
+		 %% A value set and an object cannot be distinguished
+		 %% without type information.
+		 [fun parse_FixedTypeValueSetFieldSpec/1,
+		  fun parse_VariableTypeValueSetFieldSpec/1,
+		  fun parse_TypeFieldSpec/1];
+	     [_|_] ->
+		 parse_error(Tokens0)
+	 end,
+    case parse_or(Tokens0, Fl) of
 	{Type,[{'}',_}|Rest]} ->
-	    {lists:reverse([Type|Acc]),Rest};
+	    {lists:reverse(Acc, [Type]),Rest};
 	{Type,[{',',_}|Rest2]} ->
-	    parse_FieldSpec(Rest2,[Type|Acc]);
-	{_,[H|_T]}  ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'}']}})
+	    parse_FieldSpec(Rest2, [Type|Acc])
     end.
 
 parse_PrimitiveFieldName([{typefieldreference,_,FieldName}|Rest]) ->
@@ -1100,27 +920,19 @@ parse_PrimitiveFieldName([{typefieldreference,_,FieldName}|Rest]) ->
 parse_PrimitiveFieldName([{valuefieldreference,_,FieldName}|Rest]) ->
     {{valuefieldreference,FieldName},Rest};
 parse_PrimitiveFieldName(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			[typefieldreference,valuefieldreference]]}}).
+    parse_error(Tokens).
 
 parse_FieldName(Tokens) ->
     {Field,Rest} = parse_PrimitiveFieldName(Tokens),
     parse_FieldName(Rest,[Field]).
 
-parse_FieldName([{'.',_}|Rest],Acc) ->
-    case (catch parse_PrimitiveFieldName(Rest)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	{FieldName,Rest2} ->
-	    parse_FieldName(Rest2,[FieldName|Acc])
-    end;
-parse_FieldName(Tokens,Acc) ->
+parse_FieldName([{'.',_}|Rest0],Acc) ->
+    {FieldName,Rest1} = parse_PrimitiveFieldName(Rest0),
+    parse_FieldName(Rest1, [FieldName|Acc]);
+parse_FieldName(Tokens, Acc) ->
     {lists:reverse(Acc),Tokens}.
     
-parse_FixedTypeValueFieldSpec([{valuefieldreference,L1,VFieldName}|Rest]) ->
+parse_FixedTypeValueFieldSpec([{valuefieldreference,_,VFieldName}|Rest]) ->
     {Type,Rest2} = parse_Type(Rest),
     {Unique,Rest3} = 
 	case Rest2 of
@@ -1130,109 +942,61 @@ parse_FixedTypeValueFieldSpec([{valuefieldreference,L1,VFieldName}|Rest]) ->
 		{undefined,Rest2}
 	end,
     {OptionalitySpec,Rest5} = parse_ValueOptionalitySpec(Rest3),
-    case {Unique,Rest5} of
-	{'UNIQUE',[{Del,_}|_]} when Del =:= ','; Del =:= '}' ->
-	    case OptionalitySpec of 
-		{'DEFAULT',_} ->
-		    throw({asn1_error,
-			   {L1,get(asn1_module),
-			    ['UNIQUE and DEFAULT in same field',VFieldName]}});
-		_ ->
-		    {{fixedtypevaluefield,VFieldName,Type,Unique,OptionalitySpec},Rest5}
-	    end;
-	{_,[{Del,_}|_]} when Del =:= ','; Del =:= '}'  ->
-	    {{object_or_fixedtypevalue_field,VFieldName,Type,Unique,OptionalitySpec},Rest5};
-	_ ->
-	    throw({asn1_error,{L1,get(asn1_module),
-			       [got,get_token(hd(Rest5)),expected,[',','}']]}})
-    end;
-parse_FixedTypeValueFieldSpec(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,valuefieldreference]}}).
+    case is_end_delimiter(Rest5) of
+	false -> parse_error(Rest5);
+	true -> ok
+    end,
+    Tag = case Unique of
+	      'UNIQUE' -> fixedtypevaluefield;
+	      _ -> object_or_fixedtypevalue_field
+	  end,
+    {{Tag,VFieldName,Type,Unique,OptionalitySpec},Rest5}.
+
+parse_VariableTypeValueFieldSpec([{valuefieldreference,_,VFieldName}|Rest0]) ->
+    {FieldRef,Rest1} = parse_FieldName(Rest0),
+    {OptionalitySpec,Rest} = parse_ValueOptionalitySpec(Rest1),
+    case is_end_delimiter(Rest) of
+	true ->
+	    {{variabletypevaluefield,VFieldName,FieldRef,OptionalitySpec},
+	     Rest};
+	false ->
+	    parse_error(Rest)
+    end.
 
-parse_VariableTypeValueFieldSpec([{valuefieldreference,L,VFieldName}|Rest]) ->
-    {FieldRef,Rest2} = parse_FieldName(Rest),
-    {OptionalitySpec,Rest3} = parse_ValueOptionalitySpec(Rest2),
-    case Rest3 of
-	[{Del,_}|_] when Del =:= ','; Del =:= '}' ->
-	    {{variabletypevaluefield,VFieldName,FieldRef,OptionalitySpec},Rest3};
-	_ ->
-	    throw({asn1_error,{L,get(asn1_module),
-			   [got,get_token(hd(Rest3)),expected,[',','}']]}})
-    end;
-parse_VariableTypeValueFieldSpec(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,valuefieldreference]}}).
+parse_TypeFieldSpec([{typefieldreference,_,Name}|Rest0]) ->
+    {OptionalitySpec,Rest} = parse_TypeOptionalitySpec(Rest0),
+    case is_end_delimiter(Rest) of
+	true ->
+	    {{typefield,Name,OptionalitySpec},Rest};
+	false ->
+	    parse_error(Rest)
+    end.
 
-parse_ObjectFieldSpec([{valuefieldreference,L,VFieldName}|Rest]) ->
-    {Class,Rest2} = parse_DefinedObjectClass(Rest),
-    {OptionalitySpec,Rest3} = parse_ObjectOptionalitySpec(Rest2),
-    case Rest3 of
-	[{Del,_}|_] when Del =:= ','; Del =:= '}' ->
-	    {{objectfield,VFieldName,Class,undefined,OptionalitySpec},Rest3};
-	_ ->
-	    throw({asn1_error,{L,get(asn1_module),
-			   [got,get_token(hd(Rest3)),expected,[',','}']]}})
-    end;
-parse_ObjectFieldSpec(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,valuefieldreference]}}).
+parse_FixedTypeValueSetFieldSpec([{typefieldreference,_,Name}|Rest0]) ->
+    {Type,Rest1} = parse_Type(Rest0),
+    {OptionalitySpec,Rest} = parse_ValueSetOptionalitySpec(Rest1),
+    case is_end_delimiter(Rest) of
+	true ->
+	    {{objectset_or_fixedtypevalueset_field,Name,Type,
+	      OptionalitySpec},Rest};
+	false ->
+	    parse_error(Rest)
+    end.
 
-parse_TypeFieldSpec([{typefieldreference,L,TFieldName}|Rest]) ->
-    {OptionalitySpec,Rest2} = parse_TypeOptionalitySpec(Rest),
-    case Rest2 of
-	[{Del,_}|_] when Del =:= ','; Del =:= '}' ->
-	    {{typefield,TFieldName,OptionalitySpec},Rest2};
-	_ ->
-	    throw({asn1_error,{L,get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,[',','}']]}})
-    end;
-parse_TypeFieldSpec(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,typefieldreference]}}).
+parse_VariableTypeValueSetFieldSpec([{typefieldreference,_,Name}|Rest0]) ->
+    {FieldRef,Rest1} = parse_FieldName(Rest0),
+    {OptionalitySpec,Rest} = parse_ValueSetOptionalitySpec(Rest1),
+    case is_end_delimiter(Rest) of
+	true ->
+	    {{variabletypevaluesetfield,Name,FieldRef,OptionalitySpec},
+	     Rest};
+	false ->
+	    parse_error(Rest)
+    end.
 
-parse_FixedTypeValueSetFieldSpec([{typefieldreference,L,TFieldName}|Rest]) ->
-    {Type,Rest2} = parse_Type(Rest),
-    {OptionalitySpec,Rest3} = parse_ValueSetOptionalitySpec(Rest2),
-    case Rest3 of
-	[{Del,_}|_] when Del =:= ','; Del =:= '}' ->
-	    {{objectset_or_fixedtypevalueset_field,TFieldName,Type,
-	      OptionalitySpec},Rest3};
-	_ ->
-	    throw({asn1_error,{L,get(asn1_module),
-			       [got,get_token(hd(Rest3)),expected,[',','}']]}})
-    end;  
-parse_FixedTypeValueSetFieldSpec(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,typefieldreference]}}).
-
-parse_VariableTypeValueSetFieldSpec([{typefieldreference,L,TFieldName}|Rest]) ->
-    {FieldRef,Rest2} = parse_FieldName(Rest),
-    {OptionalitySpec,Rest3} = parse_ValueSetOptionalitySpec(Rest2),
-    case Rest3 of
-	[{Del,_}|_] when Del =:= ','; Del =:= '}' ->
-	    {{variabletypevaluesetfield,TFieldName,FieldRef,OptionalitySpec},Rest3};
-	_ ->
-	    throw({asn1_error,{L,get(asn1_module),
-			       [got,get_token(hd(Rest3)),expected,[',','}']]}})
-    end; 
-parse_VariableTypeValueSetFieldSpec(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,typefieldreference]}}).
-
-parse_ObjectSetFieldSpec([{typefieldreference,L,TFieldName}|Rest]) ->
-    {Class,Rest2} = parse_DefinedObjectClass(Rest),
-    {OptionalitySpec,Rest3} = parse_ObjectSetOptionalitySpec(Rest2),
-    case Rest3 of
-	[{Del,_}|_] when Del =:= ','; Del =:= '}' ->
-	    {{objectsetfield,TFieldName,Class,OptionalitySpec},Rest3};
-	_ ->
-	    throw({asn1_error,{L,get(asn1_module),
-			       [got,get_token(hd(Rest3)),expected,[',','}']]}})
-    end;  
-parse_ObjectSetFieldSpec(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,typefieldreference]}}).
+is_end_delimiter([{',',_}|_]) -> true;
+is_end_delimiter([{'}',_}|_]) -> true;
+is_end_delimiter([_|_]) -> false.
 
 parse_ValueOptionalitySpec(Tokens)->
     case Tokens of
@@ -1243,15 +1007,6 @@ parse_ValueOptionalitySpec(Tokens)->
 	_  -> {'MANDATORY',Tokens}
     end.
 
-parse_ObjectOptionalitySpec(Tokens) ->
-    case Tokens of
-	[{'OPTIONAL',_}|Rest] -> {'OPTIONAL',Rest};
-	[{'DEFAULT',_}|Rest] ->
-	    {Object,Rest2} = parse_Object(Rest),
-	    {{'DEFAULT',Object},Rest2};
-	_  -> {'MANDATORY',Tokens}
-    end.
-
 parse_TypeOptionalitySpec(Tokens) ->
     case Tokens of
 	[{'OPTIONAL',_}|Rest] -> {'OPTIONAL',Rest};
@@ -1270,65 +1025,44 @@ parse_ValueSetOptionalitySpec(Tokens) ->
 	_  -> {'MANDATORY',Tokens}
     end.
 
-parse_ObjectSetOptionalitySpec(Tokens) ->
-        case Tokens of
-	[{'OPTIONAL',_}|Rest] -> {'OPTIONAL',Rest};
-	[{'DEFAULT',_}|Rest] ->
-	    {ObjectSet,Rest2} = parse_ObjectSet(Rest),
-	    {{'DEFAULT',ObjectSet},Rest2};
-	_  -> {'MANDATORY',Tokens}
-    end.
-
 parse_WithSyntaxSpec([{'WITH',_},{'SYNTAX',_}|Rest]) ->
     {SyntaxList,Rest2} = parse_SyntaxList(Rest),
     {{'WITH SYNTAX',SyntaxList},Rest2};
 parse_WithSyntaxSpec(Tokens) ->
     {[],Tokens}.
 
-parse_SyntaxList([{'{',_},{'}',_}|Rest]) ->
-    {[],Rest};
 parse_SyntaxList([{'{',_}|Rest]) ->
     parse_SyntaxList(Rest,[]);
 parse_SyntaxList(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,['{}','{']]}}).
+    parse_error(Tokens).
 
-parse_SyntaxList(Tokens,Acc) ->
+parse_SyntaxList(Tokens, Acc) ->
     {SyntaxList,Rest} = parse_TokenOrGroupSpec(Tokens),
     case Rest of
 	[{'}',_}|Rest2] -> 
-	    {lists:reverse([SyntaxList|Acc]),Rest2};
+	    {lists:reverse(Acc, [SyntaxList]),Rest2};
 	_ ->
-	    parse_SyntaxList(Rest,[SyntaxList|Acc])
+	    parse_SyntaxList(Rest, [SyntaxList|Acc])
     end.
 
 parse_TokenOrGroupSpec(Tokens) ->
     Flist = [fun parse_RequiredToken/1,
 	     fun parse_OptionalGroup/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
-parse_RequiredToken([{typereference,L1,WordName}|Rest]) ->
+parse_RequiredToken([{typereference,_,WordName}|Rest]=Tokens) ->
     case is_word(WordName) of
 	false ->
-	    throw({asn1_error,{L1,get(asn1_module),
-			       [got,WordName,expected,a,'Word']}});
+	    parse_error(Tokens);
 	true ->
 	    {WordName,Rest}
     end;
 parse_RequiredToken([{',',L1}|Rest]) ->
     {{',',L1},Rest};
-parse_RequiredToken([{WordName,L1}|Rest]) ->
+parse_RequiredToken([{WordName,_}|Rest]=Tokens) ->
     case is_word(WordName) of
 	false ->
-	    throw({asn1_error,{L1,get(asn1_module),
-			       [got,WordName,expected,a,'Word']}});
+	    parse_error(Tokens);
 	true ->
 	    {WordName,Rest}
     end;
@@ -1338,7 +1072,9 @@ parse_RequiredToken(Tokens) ->
 parse_OptionalGroup([{'[',_}|Rest]) ->
     {Spec,Rest2} = parse_TokenOrGroupSpec(Rest),
     {SpecList,Rest3} = parse_OptionalGroup(Rest2,[Spec]),
-    {SpecList,Rest3}.
+    {SpecList,Rest3};
+parse_OptionalGroup(Tokens) ->
+    parse_error(Tokens).
 
 parse_OptionalGroup([{']',_}|Rest],Acc) ->
     {lists:reverse(Acc),Rest};
@@ -1346,82 +1082,55 @@ parse_OptionalGroup(Tokens,Acc) ->
     {Spec,Rest} = parse_TokenOrGroupSpec(Tokens),
     parse_OptionalGroup(Rest,[Spec|Acc]).
 
-parse_DefinedObject([Id={identifier,_,_ObjName}|Rest]) ->
+parse_DefinedObject([#identifier{}=Id|Rest]) ->
     {{object,identifier2Extvalueref(Id)},Rest};
-parse_DefinedObject([{typereference,L1,ModName},{'.',_},{identifier,_,ObjName}|Rest]) ->
+parse_DefinedObject([{typereference,L1,ModName},{'.',_},#identifier{val=ObjName}|Rest]) ->
     {{object, #'Externaltypereference'{pos=L1,module=ModName,type=ObjName}},Rest};
 parse_DefinedObject(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-		       [identifier,'typereference.identifier']]}}).
+    parse_error(Tokens).
 
-parse_ObjectAssignment([{identifier,L1,ObjName}|Rest]) ->
+parse_ObjectAssignment([#identifier{pos=L1,val=ObjName}|Rest]) ->
     {Class,Rest2} = parse_DefinedObjectClass(Rest),
     case Rest2 of
 	[{'::=',_}|Rest3] ->
 	    {Object,Rest4} = parse_Object(Rest3),
 	    {#typedef{pos=L1,name=ObjName,
 		      typespec=#'Object'{classname=Class,def=Object}},Rest4};
-	[H|_T]  -> 
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}});
-	Other ->
-	    throw({asn1_error,{L1,get(asn1_module),
-			       [got,Other,expected,'::=']}})
-    end;
-parse_ObjectAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,identifier]}}).
-
+	_ ->
+	    parse_error(Rest2)
+    end.
 
 %% parse_Object(Tokens) -> Ret
 %% Tokens    = [Tok]
 %% Tok       = tuple()
 %% Ret       = {object,_} | {object, _, _}
 parse_Object(Tokens) ->
-    Flist=[fun parse_ObjectDefn/1,
-	   fun parse_ObjectFromObject/1,
-	   fun parse_ParameterizedObject/1,
-	   fun parse_DefinedObject/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    %% The ObjectFromObject production is not included here,
+    %% since it will have been catched by the ValueFromObject
+    %% before we reach this point.
+    Flist = [fun parse_ObjectDefn/1,
+	     fun parse_DefinedObject/1],
+    parse_or(Tokens, Flist).
 
 parse_ObjectDefn(Tokens) ->
     Flist=[fun parse_DefaultSyntax/1,
 	   fun parse_DefinedSyntax/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
-parse_DefaultSyntax([{'{',_},{'}',_}|Rest]) ->
-    {{object,defaultsyntax,[]},Rest};
 parse_DefaultSyntax([{'{',_}|Rest]) ->
     parse_DefaultSyntax(Rest,[]);
 parse_DefaultSyntax(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,['{}','{']]}}).
+    parse_error(Tokens).
 
-parse_DefaultSyntax(Tokens,Acc) ->
+parse_DefaultSyntax(Tokens, Acc) ->
     {Setting,Rest} = parse_FieldSetting(Tokens),
     case Rest of
 	[{',',_}|Rest2] ->
 	    parse_DefaultSyntax(Rest2,[Setting|Acc]);
 	[{'}',_}|Rest3] ->
-	    {{object,defaultsyntax,lists:reverse([Setting|Acc])},Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,[',','}']]}})
+	    {{object,defaultsyntax,lists:reverse(Acc, [Setting])},Rest3};
+	_ ->
+	    parse_error(Rest)
     end.
 
 parse_FieldSetting(Tokens) ->
@@ -1430,7 +1139,9 @@ parse_FieldSetting(Tokens) ->
     {{PrimFieldName,Setting},Rest2}.
 
 parse_DefinedSyntax([{'{',_}|Rest]) ->
-    parse_DefinedSyntax(Rest,[]).
+    parse_DefinedSyntax(Rest, []);
+parse_DefinedSyntax(Tokens) ->
+    parse_error(Tokens).
 
 parse_DefinedSyntax(Tokens,Acc) ->
     case Tokens of
@@ -1446,95 +1157,70 @@ parse_DefinedSyntax(Tokens,Acc) ->
 %% Literal ::= word | ','
 %% Setting ::= Type | Value | ValueSet | Object | ObjectSet
 %% word equals typereference, but no lower cases
-parse_DefinedSyntaxToken([{',',L1}|Rest]) ->
-    {{',',L1},Rest};
+parse_DefinedSyntaxToken([{',',_}=Comma|Rest]) ->
+    {Comma,Rest};
 %% ObjectClassFieldType or a defined type with a constraint.
 %% Should also be able to parse a parameterized type. It may be
 %% impossible to distinguish between a parameterized type and a Literal
 %% followed by an object set.
-parse_DefinedSyntaxToken(Tokens=[{typereference,L1,_Name},{T,_}|_Rest]) 
-  when T == '.'; T == '(' ->
-    case catch parse_Setting(Tokens) of
-	{asn1_error,_} ->
-	    throw({asn1_error,{L1,get(asn1_module),
-			       [got,hd(Tokens), expected,['Word',setting]]}});
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	Result ->
-	    Result
-    end;
-parse_DefinedSyntaxToken(Tokens=[TRef={typereference,L1,Name}|Rest]) ->
+parse_DefinedSyntaxToken([{typereference,_,_Name},{T,_}|_]=Tokens)
+  when T =:= '.'; T =:= '(' ->
+    parse_Setting(Tokens);
+parse_DefinedSyntaxToken([{typereference,L1,Name}=TRef|Rest]=Tokens) ->
     case is_word(Name) of
 	false ->
 	    case lookahead_definedsyntax(Rest) of
 		word_or_setting ->
 		    {{setting,L1,tref2Exttref(TRef)},Rest};
-		_ ->
+		setting ->
 		    parse_Setting(Tokens)
 	    end;
 	true ->
-	    %% {{word_or_setting,L1,Name},Rest}
 	    {{word_or_setting,L1,tref2Exttref(TRef)},Rest}
     end;
 parse_DefinedSyntaxToken(Tokens) ->
-    case catch parse_Setting(Tokens) of
-	{asn1_error,_} ->
-	    parse_Word(Tokens);
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	Result ->
+    try parse_Setting(Tokens) of
+	{_,_}=Result ->
 	    Result
+    catch
+	throw:{asn1_error,_} ->
+	    parse_Word(Tokens)
     end.
 
 lookahead_definedsyntax([{typereference,_,Name}|_Rest]) ->
-    case is_word(Name)  of
+    case is_word(Name) of
 	true -> word_or_setting;
-	_ -> setting
+	false -> setting
     end;
 lookahead_definedsyntax([{'}',_}|_Rest]) ->
     word_or_setting;
 lookahead_definedsyntax(_) ->
     setting.
 	    
-parse_Word([{Name,Pos}|Rest]) ->
+parse_Word([{Name,Pos}|Rest]=Tokens) ->
     case is_word(Name) of
 	false ->
-	    throw({asn1_error,{Pos,get(asn1_module),
-			       [got,Name, expected,a,'Word']}});
+	    parse_error(Tokens);
 	true ->
 	    {{word_or_setting,Pos,tref2Exttref(Pos,Name)},Rest}
-    end.
+    end;
+parse_Word(Tokens) ->
+    parse_error(Tokens).
 
 parse_Setting(Tokens) ->
     Flist = [{type_tag,fun parse_Type/1},
 	     {value_tag,fun parse_Value/1},
 	     {object_tag,fun parse_Object/1},
 	     {objectset_tag,fun parse_ObjectSet/1}],
-    case (catch parse_or_tag(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result = {{value_tag,_},_} ->
+    case parse_or_tag(Tokens, Flist) of
+	{{value_tag,_},_}=Result ->
+	    %% Keep the value_tag.
 	    Result;
 	{{Tag,Setting},Rest} when is_atom(Tag) ->
+	    %% Remove all other tags.
 	    {Setting,Rest}
     end.
 
-%% parse_Setting(Tokens) ->
-%%     Flist = [fun parse_Type/1,
-%% 	     fun parse_Value/1,
-%% 	     fun parse_Object/1,
-%% 	     fun parse_ObjectSet/1],
-%%     case (catch parse_or(Tokens,Flist)) of
-%% 	{'EXIT',Reason} ->
-%% 	    exit(Reason);
-%% 	AsnErr = {asn1_error,_} ->
-%% 	    throw(AsnErr);
-%% 	Result ->
-%% 	    Result
-%%     end.
-
 parse_DefinedObjectSet([{typereference,L1,ModuleName},{'.',_},
 			{typereference,L2,ObjSetName}|Rest]) ->
     {{objectset,L1,#'Externaltypereference'{pos=L2,module=ModuleName,
@@ -1543,9 +1229,7 @@ parse_DefinedObjectSet([{typereference,L1,ObjSetName}|Rest]) ->
     {{objectset,L1,#'Externaltypereference'{pos=L1,module=resolve_module(ObjSetName),
 					    type=ObjSetName}},Rest};
 parse_DefinedObjectSet(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			[typereference,'typereference.typereference']]}}).
+    parse_error(Tokens).
 
 parse_ObjectSetAssignment([{typereference,L1,ObjSetName}|Rest]) ->
     {Class,Rest2} = parse_DefinedObjectClass(Rest),
@@ -1555,16 +1239,9 @@ parse_ObjectSetAssignment([{typereference,L1,ObjSetName}|Rest]) ->
 	    {#typedef{pos=L1,name=ObjSetName,
 		      typespec=#'ObjectSet'{class=Class,
 					    set=ObjectSet}},Rest4};
-	[H|_T]  -> 
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}})
-%%%	Other ->
-%%%	    throw(Other)
-    end;
-parse_ObjectSetAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,
-				   typereference]}}).
+	_ ->
+	    parse_error(Rest2)
+    end.
 
 %% parse_ObjectSet(Tokens) -> {Ret,Rest}
 %% Tokens    = [Tok]
@@ -1581,26 +1258,20 @@ parse_ObjectSet([{'{',_}|Rest]) ->
     case Rest2 of
 	[{'}',_}|Rest3] ->
 	    {ObjSetSpec,Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'}']}})
+	_ ->
+	    parse_error(Rest2)
     end;
 parse_ObjectSet(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'{']}}).
+    parse_error(Tokens).
 
-parse_ObjectSetSpec([{'...',_}|Rest]) ->
-    case Rest of
-	[{',',_}|Rest2] ->
-	    {Elements,Rest3}=parse_ElementSetSpecs(Rest2),
-	    {{[],Elements},Rest3};
-	_ ->
-	    {['EXTENSIONMARK'],Rest}
-    end;
+parse_ObjectSetSpec([{'...',_},{',',_}|Tokens0]) ->
+    {Elements,Tokens} = parse_ElementSetSpec(Tokens0),
+    {{element_set,empty,Elements},Tokens};
+parse_ObjectSetSpec([{'...',_}|Tokens]) ->
+    {{element_set,empty,empty},Tokens};
 parse_ObjectSetSpec(Tokens) ->
     parse_ElementSetSpecs(Tokens).
 
-% moved fun parse_Object/1 and fun parse_DefinedObjectSet/1 to parse_Elements
 %% parse_ObjectSetElements(Tokens) -> {Result,Rest}
 %% Result ::= {'ObjectSetFromObjects',Objects,Name} | {pos,ObjectSet,Params}
 %% Objects ::= ReferencedObjects
@@ -1610,18 +1281,9 @@ parse_ObjectSetSpec(Tokens) ->
 %% ObjectSet ::= {objectset,integer(),#'Externaltypereference'{}}
 %% Params ::= list() (see parse_ActualParameterList/1)
 parse_ObjectSetElements(Tokens) ->
-    Flist = [%fun parse_Object/1,
-	     %fun parse_DefinedObjectSet/1,
-	     fun parse_ObjectSetFromObjects/1,
+    Flist = [fun parse_ObjectSetFromObjects/1,
 	     fun parse_ParameterizedObjectSet/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_ObjectClassFieldType(Tokens) ->
     {Class,Rest} = parse_DefinedObjectClass(Tokens),
@@ -1632,25 +1294,10 @@ parse_ObjectClassFieldType(Tokens) ->
 	      classname=Class,
 	      class=Class,fieldname=FieldName},
 	    {#type{def=OCFT},Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'.']}})
-%%%	Other ->
-%%%	    throw(Other)
+	_ ->
+	    parse_error(Rest)
     end.
 
-%parse_ObjectClassFieldValue(Tokens) ->
-%    Flist = [fun parse_OpenTypeFieldVal/1,
-%	     fun parse_FixedTypeFieldVal/1],
-%    case (catch parse_or(Tokens,Flist)) of
-%	{'EXIT',Reason} ->
-%	    throw(Reason);
-%	AsnErr = {asn1_error,_} ->
-%	    throw(AsnErr);
-%	Result ->
-%	    Result
-%    end.
-
 parse_ObjectClassFieldValue(Tokens) ->
     parse_OpenTypeFieldVal(Tokens).
 
@@ -1660,28 +1307,10 @@ parse_OpenTypeFieldVal(Tokens) ->
 	[{':',_}|Rest2] ->
 	    {Value,Rest3} = parse_Value(Rest2),
 	    {{opentypefieldvalue,Type,Value},Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,':']}})
+	_ ->
+	    parse_error(Rest)
     end.
 
-% parse_FixedTypeFieldVal(Tokens) ->
-%     parse_Value(Tokens).
-
-% parse_InformationFromObjects(Tokens) ->
-%     Flist = [fun parse_ValueFromObject/1,
-% 	     fun parse_ValueSetFromObjects/1,
-% 	     fun parse_TypeFromObject/1,
-% 	     fun parse_ObjectFromObject/1],
-%     case (catch parse_or(Tokens,Flist)) of
-% 	{'EXIT',Reason} ->
-% 	    throw(Reason);
-% 	AsnErr = {asn1_error,_} ->
-% 	    throw(AsnErr);
-% 	Result ->
-% 	    Result
-%     end.
-
 %% parse_ReferencedObjects(Tokens) -> {Result,Rest}
 %% Result    ::= DefObject | DefObjSet |
 %%               {po,DefObject,Params} | {pos,DefObjSet,Params} |
@@ -1693,18 +1322,11 @@ parse_OpenTypeFieldVal(Tokens) ->
 parse_ReferencedObjects(Tokens) ->
     Flist = [fun parse_DefinedObject/1,
 	     fun parse_DefinedObjectSet/1,
-	     fun parse_ParameterizedObject/1,
 	     fun parse_ParameterizedObjectSet/1],
-        case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_ValueFromObject(Tokens) ->
+    %% This production also matches ObjectFromObject.
     {Objects,Rest} = parse_ReferencedObjects(Tokens),
     case Rest of
 	[{'.',_}|Rest2] ->
@@ -1713,35 +1335,10 @@ parse_ValueFromObject(Tokens) ->
 		{valuefieldreference,_} ->
 		    {{'ValueFromObject',Objects,Name},Rest3};
 		_ ->
-		    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-				       [got,typefieldreference,expected,
-					valuefieldreference]}})
+		    parse_error(Rest2)
 	    end;
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'.']}})
-%%%	Other ->
-%%%	    throw({asn1_error,{got,Other,expected,'.'}})
-    end.
-
-parse_ValueSetFromObjects(Tokens) ->
-    {Objects,Rest} = parse_ReferencedObjects(Tokens),
-    case Rest of
-	[{'.',_}|Rest2] ->
-	    {Name,Rest3} = parse_FieldName(Rest2),
-	    case lists:last(Name) of
-		{typefieldreference,_FieldName} ->
-		    {{'ValueSetFromObjects',Objects,Name},Rest3};
-		_ ->
-		    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-				       [got,get_token(hd(Rest2)),expected,
-					typefieldreference]}})
-	    end;
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'.']}})
-%%%	Other ->
-%%%	    throw({asn1_error,{got,Other,expected,'.'}})
+	_ ->
+	    parse_error(Rest)
     end.
 
 parse_TypeFromObject(Tokens) ->
@@ -1751,28 +1348,12 @@ parse_TypeFromObject(Tokens) ->
 	    {Name,Rest3} = parse_FieldName(Rest2),
 	    case lists:last(Name) of
 		{typefieldreference,_FieldName} ->
-		    {{'TypeFromObject',Objects,Name},Rest3};
+		    {#type{def={'TypeFromObject',Objects,Name}},Rest3};
 		_ ->
-		    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-				       [got,get_token(hd(Rest2)),expected,
-					typefieldreference]}})
+		    parse_error(Rest2)
 	    end;
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'.']}})
-%%%	Other ->
-%%%	    throw({asn1_error,{got,Other,expected,'.'}})
-    end.
-
-parse_ObjectFromObject(Tokens) ->
-    {Objects,Rest} = parse_ReferencedObjects(Tokens),
-    case Rest of
-	[{'.',_}|Rest2] ->
-	    {Name,Rest3} = parse_FieldName(Rest2),
-	    {{'ObjectFromObject',Objects,Name},Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'.']}})
+	_ ->
+	    parse_error(Rest)
     end.
 
 %% parse_ObjectSetFromObjects(Tokens) -> {Result,Rest}
@@ -1790,23 +1371,12 @@ parse_ObjectSetFromObjects(Tokens) ->
 		{typefieldreference,_FieldName} ->
 		    {{'ObjectSetFromObjects',Objects,Name},Rest3};
 		_ ->
-		    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-				       [got,get_token(hd(Rest2)),expected,
-					typefieldreference]}})
+		    parse_error(Rest2)
 	    end;
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'.']}})
+	_ ->
+	    parse_error(Rest)
     end.
 
-% parse_InstanceOfType([{'INSTANCE',_},{'OF',_}|Rest]) ->
-%     {Class,Rest2} = parse_DefinedObjectClass(Rest),
-%     {{'InstanceOfType',Class},Rest2}.
-
-% parse_InstanceOfValue(Tokens) ->
-%     parse_Value(Tokens).
-
-
 
 %% X.682 constraint specification
 
@@ -1814,14 +1384,7 @@ parse_GeneralConstraint(Tokens) ->
     Flist = [fun parse_UserDefinedConstraint/1,
 	     fun parse_TableConstraint/1,
 	     fun parse_ContentsConstraint/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_UserDefinedConstraint([{'CONSTRAINED',_},{'BY',_},{'{',_},{'}',_}|Rest])->
     {{constrained_by,[]},Rest};
@@ -1832,32 +1395,23 @@ parse_UserDefinedConstraint([{'CONSTRAINED',_},
     case Rest2 of
 	[{'}',_}|Rest3] ->
 	    {{constrained_by,Param},Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'}']}})
+	_ ->
+	    parse_error(Rest2)
     end;
 parse_UserDefinedConstraint(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			['CONSTRAINED BY {}','CONSTRAINED BY {']]}}).
+    parse_error(Tokens).
 
 parse_UserDefinedConstraintParameter(Tokens) ->
-    parse_UserDefinedConstraintParameter(Tokens,[]).
-parse_UserDefinedConstraintParameter(Tokens,Acc) ->
+    parse_UserDefinedConstraintParameter(Tokens, []).
+
+parse_UserDefinedConstraintParameter(Tokens0, Acc) ->
     Flist = [fun parse_GovernorAndActualParameter/1,
 	     fun parse_ActualParameter/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	{Result,Rest} ->
-	    case Rest of
-		[{',',_}|_Rest2] ->
-		    parse_UserDefinedConstraintParameter(Tokens,[Result|Acc]);
-		_  ->
-		    {lists:reverse([Result|Acc]),Rest}
-	    end
+    case parse_or(Tokens0, Flist) of
+	{Result,[{',',_}|Tokens]} ->
+	    parse_UserDefinedConstraintParameter(Tokens, [Result|Acc]);
+	{Result,Tokens} ->
+	    {lists:reverse(Acc, [Result]),Tokens}
     end.
 
 parse_GovernorAndActualParameter(Tokens) ->
@@ -1866,26 +1420,18 @@ parse_GovernorAndActualParameter(Tokens) ->
 	[{':',_}|Rest2] ->
 	    {Params,Rest3} = parse_ActualParameter(Rest2),
 	    {{'Governor_Params',Governor,Params},Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,':']}})
+	_ ->
+	    parse_error(Rest)
     end.
 
 parse_TableConstraint(Tokens) ->
     Flist = [fun parse_ComponentRelationConstraint/1,
 	     fun parse_SimpleTableConstraint/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_SimpleTableConstraint(Tokens) ->
     {ObjectSet,Rest} = parse_ObjectSet(Tokens),
-    {{simpletable,ObjectSet},Rest}.
+    {{element_set,{simpletable,ObjectSet},none},Rest}.
 
 parse_ComponentRelationConstraint([{'{',_}|Rest]) ->
     {ObjectSet,Rest2} = parse_DefinedObjectSet(Rest),
@@ -1894,21 +1440,18 @@ parse_ComponentRelationConstraint([{'{',_}|Rest]) ->
 	    {AtNot,Rest4} = parse_AtNotationList(Rest3,[]),
 	    case Rest4 of
 		[{'}',_}|Rest5] ->
-		    {{componentrelation,ObjectSet,AtNot},Rest5};
-		[H|_T]  ->
-		    throw({asn1_error,{get_line(H),get(asn1_module),
-				       [got,get_token(H),expected,'}']}})
+		    Ret = {element_set,
+			   {componentrelation,ObjectSet,AtNot},
+			   none},
+		    {Ret,Rest5};
+		_ ->
+		    parse_error(Rest4)
 	    end;
-	[H|_T]  ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,
-				'ComponentRelationConstraint',ended,with,'}']}})
-%%%	Other ->
-%%%	    throw(Other)
+	_  ->
+	    parse_error(Rest2)
     end;
 parse_ComponentRelationConstraint(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'{']}}).
+    parse_error(Tokens).
 
 parse_AtNotationList(Tokens,Acc) ->
     {AtNot,Rest} = parse_AtNotation(Tokens),
@@ -1916,7 +1459,7 @@ parse_AtNotationList(Tokens,Acc) ->
 	[{',',_}|Rest2] ->
 	    parse_AtNotationList(Rest2,[AtNot|Acc]);
 	_  ->
-	    {lists:reverse([AtNot|Acc]),Rest}
+	    {lists:reverse(Acc, [AtNot]),Rest}
     end.
 
 parse_AtNotation([{'@',_},{'.',_}|Rest]) ->
@@ -1926,20 +1469,17 @@ parse_AtNotation([{'@',_}|Rest]) ->
     {CIdList,Rest2} = parse_ComponentIdList(Rest),
     {{outermost,CIdList},Rest2};
 parse_AtNotation(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,['@','@.']]}}).
+    parse_error(Tokens).
 
 parse_ComponentIdList(Tokens) ->
     parse_ComponentIdList(Tokens,[]).
 
-parse_ComponentIdList([Id = {identifier,_,_},{'.',_}|Rest],Acc) ->
+parse_ComponentIdList([#identifier{}=Id,{'.',_}|Rest], Acc) ->
     parse_ComponentIdList(Rest,[identifier2Extvalueref(Id)|Acc]);
-parse_ComponentIdList([Id = {identifier,_,_}|Rest],Acc) ->
-    {lists:reverse([identifier2Extvalueref(Id)|Acc]),Rest};
+parse_ComponentIdList([#identifier{}=Id|Rest], Acc) ->
+    {lists:reverse(Acc, [identifier2Extvalueref(Id)]),Rest};
 parse_ComponentIdList(Tokens,_) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			[identifier,'identifier.']]}}).
+    parse_error(Tokens).
 
 parse_ContentsConstraint([{'CONTAINING',_}|Rest]) ->
     {Type,Rest2} = parse_Type(Rest),
@@ -1954,24 +1494,14 @@ parse_ContentsConstraint([{'ENCODED',_},{'BY',_}|Rest]) ->
     {Value,Rest2} = parse_Value(Rest),
     {{contentsconstraint,[],Value},Rest2};
 parse_ContentsConstraint(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			'CONTAINING','or','ENCODED BY']}}).
-
+    parse_error(Tokens).
 
 % X.683 Parameterization of ASN.1 specifications
 
 parse_Governor(Tokens) ->
     Flist = [fun parse_Type/1,
 	     fun parse_DefinedObjectClass/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_ActualParameter(Tokens) ->
     Flist = [fun parse_Type/1,
@@ -1980,32 +1510,7 @@ parse_ActualParameter(Tokens) ->
 	     fun parse_DefinedObjectClass/1,
 	     fun parse_Object/1,
 	     fun parse_ObjectSet/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
-
-parse_ParameterizedAssignment(Tokens) ->
-    Flist = [fun parse_ParameterizedTypeAssignment/1,
-	     fun parse_ParameterizedValueAssignment/1,
-	     fun parse_ParameterizedValueSetTypeAssignment/1,
-	     fun parse_ParameterizedObjectClassAssignment/1,
-	     fun parse_ParameterizedObjectAssignment/1,
-	     fun parse_ParameterizedObjectSetAssignment/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	AsnAssErr = {asn1_assignment_error,_} ->
-	    throw(AsnAssErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 %% parse_ParameterizedTypeAssignment(Tokens) -> Result
 %% Result = {#ptypedef{},Rest} | throw()
@@ -2016,18 +1521,13 @@ parse_ParameterizedTypeAssignment([{typereference,L1,Name}|Rest]) ->
 	    {Type,Rest4} = parse_Type(Rest3),
 	    {#ptypedef{pos=L1,name=Name,args=ParameterList,typespec=Type},
 	     Rest4};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}})
-    end;
-parse_ParameterizedTypeAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,
-				   typereference]}}).
+	_ ->
+	    parse_error(Rest2)
+    end.
 
 %% parse_ParameterizedValueAssignment(Tokens) -> Result
 %% Result = {#pvaluedef{},Rest} | throw()
-parse_ParameterizedValueAssignment([{identifier,L1,Name}|Rest]) ->
+parse_ParameterizedValueAssignment([#identifier{pos=L1,val=Name}|Rest]) ->
     {ParameterList,Rest2} = parse_ParameterList(Rest),
     {Type,Rest3} = parse_Type(Rest2),
     case Rest3 of
@@ -2035,13 +1535,9 @@ parse_ParameterizedValueAssignment([{identifier,L1,Name}|Rest]) ->
 	    {Value,Rest5} = parse_Value(Rest4),
 	    {#pvaluedef{pos=L1,name=Name,args=ParameterList,type=Type,
 			 value=Value},Rest5};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}})
-    end;
-parse_ParameterizedValueAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,identifier]}}).
+	_ ->
+	    parse_error(Rest3)
+    end.
 
 %% parse_ParameterizedValueSetTypeAssignment(Tokens) -> Result
 %% Result = {#pvaluesetdef{},Rest} | throw()
@@ -2053,14 +1549,9 @@ parse_ParameterizedValueSetTypeAssignment([{typereference,L1,Name}|Rest]) ->
 	    {ValueSet,Rest5} = parse_ValueSet(Rest4),
 	    {#pvaluesetdef{pos=L1,name=Name,args=ParameterList,
 			   type=Type,valueset=ValueSet},Rest5};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}})
-    end;
-parse_ParameterizedValueSetTypeAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,
-				   typereference]}}).
+	_ ->
+	    parse_error(Rest3)
+    end.
 
 %% parse_ParameterizedObjectClassAssignment(Tokens) -> Result
 %% Result = {#ptypedef{},Rest} | throw()
@@ -2071,18 +1562,13 @@ parse_ParameterizedObjectClassAssignment([{typereference,L1,Name}|Rest]) ->
 	    {Class,Rest4} = parse_ObjectClass(Rest3),
 	    {#ptypedef{pos=L1,name=Name,args=ParameterList,typespec=Class},
 	     Rest4};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}})
-    end;
-parse_ParameterizedObjectClassAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,
-				   typereference]}}).
+	_ ->
+	    parse_error(Rest2)
+    end.
 
 %% parse_ParameterizedObjectAssignment(Tokens) -> Result
 %% Result = {#pobjectdef{},Rest} | throw()
-parse_ParameterizedObjectAssignment([{identifier,L1,Name}|Rest]) ->
+parse_ParameterizedObjectAssignment([#identifier{pos=L1,val=Name}|Rest]) ->
     {ParameterList,Rest2} = parse_ParameterList(Rest),
     {Class,Rest3} = parse_DefinedObjectClass(Rest2),
     case Rest3 of
@@ -2090,74 +1576,35 @@ parse_ParameterizedObjectAssignment([{identifier,L1,Name}|Rest]) ->
 	    {Object,Rest5} = parse_Object(Rest4),
 	    {#pobjectdef{pos=L1,name=Name,args=ParameterList,
 			 class=Class,def=Object},Rest5};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}})
-%%%	Other ->
-%%%	    throw(Other)
-    end;
-parse_ParameterizedObjectAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,identifier]}}).
-
-%% parse_ParameterizedObjectSetAssignment(Tokens) -> Result
-%% Result = {#pobjectsetdef{},Rest} | throw{}
-parse_ParameterizedObjectSetAssignment([{typereference,L1,Name}|Rest]) ->
-    {ParameterList,Rest2} = parse_ParameterList(Rest),
-    {Class,Rest3} = parse_DefinedObjectClass(Rest2),
-    case Rest3 of
-	[{'::=',_}|Rest4] ->
-	    {ObjectSet,Rest5} = parse_ObjectSet(Rest4),
-	    {#pobjectsetdef{pos=L1,name=Name,args=ParameterList,
-			    class=Class,def=ObjectSet},Rest5};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}})
-%%%	Other ->
-%%%	    throw(Other)
-    end;
-parse_ParameterizedObjectSetAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,
-				   typereference]}}).
+	_ ->
+	    parse_error(Rest3)
+    end.
 
 %% parse_ParameterList(Tokens) -> Result
 %% Result = [Parameter]
 %% Parameter = {Governor,Reference} | Reference
 %% Governor = Type | DefinedObjectClass
 %% Type = #type{}
-%% DefinedObjectClass = #'Externaltypereference'{} | 
-%%                      'ABSTRACT-SYNTAX' | 'TYPE-IDENTIFIER'
+%% DefinedObjectClass = #'Externaltypereference'{}
 %% Reference = #'Externaltypereference'{} | #'Externalvaluereference'{}
-parse_ParameterList([{'{',_}|Rest]) ->
-    parse_ParameterList(Rest,[]);
-parse_ParameterList(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'{']}}).
+parse_ParameterList([{'{',_}|Tokens]) ->
+    parse_ParameterList(Tokens, []).
 
 parse_ParameterList(Tokens,Acc) ->
     {Parameter,Rest} = parse_Parameter(Tokens),
     case Rest of
 	[{',',_}|Rest2] ->
-	    parse_ParameterList(Rest2,[Parameter|Acc]);
+	    parse_ParameterList(Rest2, [Parameter|Acc]);
 	[{'}',_}|Rest3] ->
-	    {lists:reverse([Parameter|Acc]),Rest3};
-	[H|_T]  ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,[',','}']]}})
+	    {lists:reverse(Acc, [Parameter]),Rest3};
+	_ ->
+	    parse_error(Rest)
     end.
 
 parse_Parameter(Tokens) ->
     Flist = [fun parse_ParamGovAndRef/1,
 	     fun parse_Reference/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_ParamGovAndRef(Tokens) ->
     {ParamGov,Rest} = parse_ParamGovernor(Tokens),
@@ -2165,86 +1612,54 @@ parse_ParamGovAndRef(Tokens) ->
 	[{':',_}|Rest2] ->
 	    {Ref,Rest3} = parse_Reference(Rest2),
 	    {{ParamGov,Ref},Rest3};
-	[H|_T] ->
-	   throw({asn1_error,{get_line(H),get(asn1_module),
-			      [got,get_token(H),expected,':']}})
+	_ ->
+	    parse_error(Rest)
     end.
 
 parse_ParamGovernor(Tokens) ->
     Flist = [fun parse_Governor/1,
 	     fun parse_Reference/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
-
-% parse_ParameterizedReference(Tokens) ->
-%     {Ref,Rest} = parse_Reference(Tokens),
-%     case Rest of
-% 	[{'{',_},{'}',_}|Rest2] ->
-% 	    {{ptref,Ref},Rest2};
-% 	_  ->
-% 	    {{ptref,Ref},Rest}
-%     end.
+    parse_or(Tokens, Flist).
 
 parse_SimpleDefinedType([{typereference,L1,ModuleName},{'.',_},
 			 {typereference,_,TypeName}|Rest]) ->
     {#'Externaltypereference'{pos=L1,module=ModuleName,
 						 type=TypeName},Rest};
 parse_SimpleDefinedType([Tref={typereference,_,_}|Rest]) ->
-%    {#'Externaltypereference'{pos=L2,module=get(asn1_module),
-%						 type=TypeName},Rest};
     {tref2Exttref(Tref),Rest};
 parse_SimpleDefinedType(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			[typereference,'typereference.typereference']]}}).
+    parse_error(Tokens).
 
 parse_SimpleDefinedValue([{typereference,L1,ModuleName},{'.',_},
-			  {identifier,_,Value}|Rest]) ->
+			  #identifier{val=Value}|Rest]) ->
     {{simpledefinedvalue,#'Externalvaluereference'{pos=L1,module=ModuleName,
 						   value=Value}},Rest};
-parse_SimpleDefinedValue([Id={identifier,_,_Value}|Rest]) ->
+parse_SimpleDefinedValue([#identifier{}=Id|Rest]) ->
     {{simpledefinedvalue,identifier2Extvalueref(Id)},Rest};
 parse_SimpleDefinedValue(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			['typereference.identifier',identifier]]}}).
+    parse_error(Tokens).
 
 parse_ParameterizedType(Tokens) ->
+    %% May also be a parameterized class.
     {Type,Rest} = parse_SimpleDefinedType(Tokens),
     {Params,Rest2} = parse_ActualParameterList(Rest),
-    {{pt,Type,Params},Rest2}.
+    {#type{def={pt,Type,Params}},Rest2}.
 
 parse_ParameterizedValue(Tokens) ->
+    %% May also be a parameterized object.
     {Value,Rest} = parse_SimpleDefinedValue(Tokens),
     {Params,Rest2} = parse_ActualParameterList(Rest),
     {{pv,Value,Params},Rest2}.
 
-parse_ParameterizedObjectClass(Tokens) ->
-    {Type,Rest} = parse_DefinedObjectClass(Tokens),
-    {Params,Rest2} = parse_ActualParameterList(Rest),
-    {{poc,Type,Params},Rest2}.
-
 parse_ParameterizedObjectSet(Tokens) ->
     {ObjectSet,Rest} = parse_DefinedObjectSet(Tokens),
     {Params,Rest2} = parse_ActualParameterList(Rest),
     {{pos,ObjectSet,Params},Rest2}.
 
-parse_ParameterizedObject(Tokens) ->
-    {Object,Rest} = parse_DefinedObject(Tokens),
-    {Params,Rest2} = parse_ActualParameterList(Rest),
-    {{po,Object,Params},Rest2}.
-
 parse_ActualParameterList([{'{',_}|Rest]) ->
     parse_ActualParameterList(Rest,[]);
 parse_ActualParameterList(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'{']}}).
+    parse_error(Tokens).
 
 parse_ActualParameterList(Tokens,Acc) ->
     {Parameter,Rest} = parse_ActualParameter(Tokens),
@@ -2252,43 +1667,22 @@ parse_ActualParameterList(Tokens,Acc) ->
 	[{',',_}|Rest2] ->
 	    parse_ActualParameterList(Rest2,[Parameter|Acc]);
 	[{'}',_}|Rest3] ->
-	    {lists:reverse([Parameter|Acc]),Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,[',','}']]}})
-%%%	Other ->
-%%%	    throw(Other)
+	    {lists:reverse(Acc, [Parameter]),Rest3};
+	_ ->
+	    parse_error(Rest)
     end.
 
-
-
-
-
-
-
-%-------------------------
-
+%% Test whether Token is allowed in a syntax list.
 is_word(Token) ->
-    case not_allowed_word(Token) of
+    List = atom_to_list(Token),
+    case not_allowed_word(List) of
 	true -> false;
-	_ ->
-	    if
-		is_atom(Token) ->
-		    Item = atom_to_list(Token),
-		    is_word(Item);
-		is_list(Token), length(Token) == 1 ->
-		    check_one_char_word(Token);
-		is_list(Token) ->
-		    [A|Rest] = Token,
-		    case check_first(A) of
-			true ->
-			    check_rest(Rest);
-			_ -> 
-			    false
-		    end
-	    end
+	false -> is_word_1(List)
     end.
 
+is_word_1([H|T]) ->
+    check_first(H) andalso check_rest(T).
+
 not_allowed_word(Name) ->
     lists:member(Name,["BIT",
 		       "BOOLEAN",
@@ -2313,257 +1707,123 @@ not_allowed_word(Name) ->
 		       "TRUE",
 		       "UNION"]).
 
-check_one_char_word([A]) when $A =< A, $Z >= A ->
-    true;
-check_one_char_word([_]) ->
-    false. %% unknown item in SyntaxList
+check_first(C) ->
+    $A =< C andalso C =< $Z.
 
-check_first(A) when $A =< A, $Z >= A ->
-    true;
-check_first(_) ->
-    false. %% unknown item in SyntaxList
-
-check_rest([R,R|_Rs]) when $- == R ->
-    false; %% two consecutive hyphens are not allowed in a word
-check_rest([R]) when $- == R ->
-    false; %% word cannot end with hyphen
-check_rest([R|Rs]) when $A=<R, $Z>=R; $-==R ->
+check_rest([R|Rs]) when $A =< R, R =< $Z; R =:= $- ->
     check_rest(Rs);
 check_rest([]) ->
     true;
 check_rest(_) ->
     false.
 
+%%%
+%%% Parse alternative type lists for CHOICE.
+%%%
+
+parse_AlternativeTypeLists(Tokens0) ->
+    {Root,Tokens1} = parse_AlternativeTypeList(Tokens0),
+    case Tokens1 of
+	[{',',_}|Tokens2] ->
+	    {ExtMarker,Tokens3} = parse_ExtensionAndException(Tokens2),
+	    {ExtAlts,Tokens4} =	parse_ExtensionAdditionAlternatives(Tokens3),
+	    {_,Tokens} = parse_OptionalExtensionMarker(Tokens4, []),
+	    {Root++ExtMarker++ExtAlts,Tokens};
+	Tokens ->
+	    {Root,Tokens}
+    end.
+
+parse_ExtensionAndException([{'...',L}|Tokens0]) ->
+    {[#'EXTENSIONMARK'{pos=L}],
+     case Tokens0 of
+	 [{'!',_}|Tokens1] ->
+	     {_,Tokens} = parse_ExceptionIdentification(Tokens1),
+	     Tokens;
+	 _ ->
+	     Tokens0
+     end}.
+
+parse_AlternativeTypeList([#identifier{}|_]=Tokens0) ->
+    {AltType,Tokens} = parse_NamedType(Tokens0),
+    parse_AlternativeTypeList_1(Tokens, [AltType]);
+parse_AlternativeTypeList(Tokens) ->
+    parse_error(Tokens).
+
+parse_AlternativeTypeList_1([{',',_}|[#identifier{}|_]=Tokens0], Acc) ->
+    {AltType,Tokens} = parse_NamedType(Tokens0),
+    parse_AlternativeTypeList_1(Tokens, [AltType|Acc]);
+parse_AlternativeTypeList_1(Tokens, Acc) ->
+    {lists:reverse(Acc),Tokens}.
 
-to_set(V) when is_list(V) ->
-	ordsets:from_list(V);
-to_set(V) ->
-	ordsets:from_list([V]).
-
-parse_AlternativeTypeLists(Tokens) ->
-    parse_AlternativeTypeLists(Tokens,[]).
-
-parse_AlternativeTypeLists(Tokens = [{identifier,_,_}|_Rest0],Clist) ->
-    {CompList,Rest1} = parse_AlternativeTypeList(Tokens,[]),
-    parse_AlternativeTypeLists(Rest1,Clist++CompList);
-parse_AlternativeTypeLists([{'...',L1},{'!',_}|Rest02],Clist0) ->
-    {_,Rest03} = parse_ExceptionIdentification(Rest02),
-    %% Exception info is currently thrown away
-    parse_AlternativeTypeLists2(Rest03,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
-parse_AlternativeTypeLists([{',',L1},{'...',_},{'!',_}|Rest02],Clist0) when Clist0 =/= []->
-    {_,Rest03} = parse_ExceptionIdentification(Rest02),
-    %% Exception info is currently thrown away
-    parse_AlternativeTypeLists2(Rest03,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
-
-parse_AlternativeTypeLists([{',',_},{'...',L1}|Rest02],Clist0) when Clist0 =/= []->
-    parse_AlternativeTypeLists2(Rest02,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
-parse_AlternativeTypeLists([{'...',L1}|Rest02],Clist0) ->
-    parse_AlternativeTypeLists2(Rest02,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
-parse_AlternativeTypeLists(Tokens = [{'}',_L1}|_Rest02],Clist0) ->
-    {Clist0,Tokens}.
-
-parse_AlternativeTypeLists2(Tokens,Clist) ->
-    {ExtAdd,Rest} = parse_ExtensionAdditionAlternatives(Tokens,Clist),
-    {Clist2,Rest2} = parse_OptionalExtensionMarker(Rest,lists:flatten(ExtAdd)),
-    case Rest2 of
-	[{',',_}|Rest3] ->
-	    {CompList,Rest4} = parse_AlternativeTypeList(Rest3,[]),
-	    {Clist2 ++ CompList,Rest4};
-	_ ->
-	    {Clist2,Rest2}
-    end.
-
-
-
-parse_AlternativeTypeList([{',',_},Id = {identifier,_,_}|Rest],Acc) when Acc =/= [] ->
-    {AlternativeType,Rest2} = parse_NamedType([Id|Rest]),
-    parse_AlternativeTypeList(Rest2,[AlternativeType|Acc]);
-parse_AlternativeTypeList(Tokens = [{'}',_}|_],Acc) ->
-    {lists:reverse(Acc),Tokens};
-parse_AlternativeTypeList(Tokens = [{']',_},{']',_}|_],Acc) ->
-    {lists:reverse(Acc),Tokens};
-parse_AlternativeTypeList(Tokens = [{',',_},{'...',_}|_],Acc) ->
-    {lists:reverse(Acc),Tokens};
-parse_AlternativeTypeList(Tokens,[]) ->
-    {AlternativeType,Rest} = parse_NamedType(Tokens),
-    parse_AlternativeTypeList(Rest,[AlternativeType]);
-parse_AlternativeTypeList(Tokens,_) ->
-    throw({asn1_error,
-	   {get_line(hd(Tokens)),get(asn1_module),
-	    [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
-	     expected,['}',', identifier']]}}).
-
-parse_ExtensionAdditionAlternatives(Tokens =[{',',_}|_],Clist) ->
-    {ExtAddList,Rest2} = parse_ExtensionAdditionAlternativesList(Tokens,[]),
-    {Clist++lists:flatten(ExtAddList),Rest2};
-parse_ExtensionAdditionAlternatives(Tokens,Clist) ->
-    %% Empty
-    {Clist,Tokens}.
+parse_ExtensionAdditionAlternatives([{',',_}|_]=Tokens0) ->
+    parse_ExtensionAdditionAlternativesList(Tokens0, []);
+parse_ExtensionAdditionAlternatives(Tokens) ->
+    {[],Tokens}.
 
-parse_ExtensionAdditionAlternativesList([{',',_},Id = {identifier,_,_}|Rest],Acc) ->
-    {AlternativeType,Rest2} = parse_NamedType([Id|Rest]),
-    parse_ExtensionAdditionAlternativesList(Rest2,[AlternativeType|Acc]);
-parse_ExtensionAdditionAlternativesList([{',',_},C1 = {'[',_},C2 = {'[',_}|Rest],Acc) ->
-    {ExtAddGroup,Rest2} = parse_ExtensionAdditionAlternativesGroup([C1,C2|Rest],[]),
-    parse_ExtensionAdditionAlternativesList(Rest2,[ExtAddGroup|Acc]);
-parse_ExtensionAdditionAlternativesList(Tokens = [{'}',_}|_],Acc) ->
-    {lists:reverse(Acc),Tokens};
-parse_ExtensionAdditionAlternativesList(Tokens = [{',',_},{'...',_}|_],Acc) ->
-    {lists:reverse(Acc),Tokens};
-parse_ExtensionAdditionAlternativesList(Tokens,_) ->
-    throw({asn1_error,
-	   {get_line(hd(Tokens)),get(asn1_module),
-	    [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
-	     expected,['}',', identifier']]}}).
-
-
-parse_ExtensionAdditionAlternativesGroup([ {'[',_},{'[',_},_VsnNr = {number,_,Num},{':',_}|Rest],[]) ->
-    parse_ExtensionAdditionAlternativesGroup2(Rest,Num);
-parse_ExtensionAdditionAlternativesGroup([ {'[',_},{'[',_}|Rest],[]) ->
-    parse_ExtensionAdditionAlternativesGroup2(Rest,undefined);
-parse_ExtensionAdditionAlternativesGroup(Tokens,_) ->
-    throw({asn1_error,
-	   {get_line(hd(Tokens)),get(asn1_module),
-	    [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
-	     expected,['[[']]}}).
-
-
-parse_ExtensionAdditionAlternativesGroup2(Tokens,Num) ->
-    {CompTypeList,Rest} = parse_AlternativeTypeList(Tokens,[]),
-    case Rest of
-	[{']',_},{']',_}|Rest2] ->
-	    {[{'ExtensionAdditionGroup',Num}|CompTypeList] ++
-		['ExtensionAdditionGroupEnd'],Rest2};
+parse_ExtensionAdditionAlternativesList([{',',_}|Tokens1]=Tokens0, Acc) ->
+    try parse_ExtensionAdditionAlternative(Tokens1) of
+	{ExtAddAlt,Tokens2} ->
+	    parse_ExtensionAdditionAlternativesList(Tokens2, [ExtAddAlt|Acc])
+    catch
+	throw:{asn1_error,_} ->
+	    {lists:append(lists:reverse(Acc)),Tokens0}
+    end;
+parse_ExtensionAdditionAlternativesList(Tokens, Acc) ->
+    {lists:append(lists:reverse(Acc)),Tokens}.
+
+parse_ExtensionAdditionAlternative([#identifier{}|_]=Tokens0) ->
+    {NamedType,Tokens} = parse_NamedType(Tokens0),
+    {[NamedType],Tokens};
+parse_ExtensionAdditionAlternative([{'[',_},{'[',_}|Tokens0]) ->
+    Tokens2 = case Tokens0 of
+		  [{number,_,_},{':',_}|Tokens1] -> Tokens1;
+		  _ -> Tokens0
+	      end,
+    {GroupList,Tokens3} = parse_AlternativeTypeList(Tokens2),
+    case Tokens3 of
+	[{']',_},{']',_}|Tokens] ->
+	    {GroupList,Tokens};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
-			       [got,get_token(hd(Rest)),expected,[']]']]}})
-    end.
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-%% parse_AlternativeTypeLists(Tokens,ExtensionDefault) ->
-%%     {AltTypeList,Rest1} = parse_AlternativeTypeList(Tokens),
-%%     {ExtensionAndException,Rest2} =
-%% 	case Rest1 of
-%% 	    [{',',_},{'...',L1},{'!',_}|Rest12] ->
-%% 		{_,Rest13} = parse_ExceptionIdentification(Rest12),
-%% 		%% Exception info is currently thrown away
-%% 		{[#'EXTENSIONMARK'{pos=L1}],Rest13};
-%% 	    [{',',_},{'...',L1}|Rest12] ->
-%% 		{[#'EXTENSIONMARK'{pos=L1}],Rest12};
-%% 	    _ ->
-%% 		{[],Rest1}
-%% 	end,
-%%     {AltTypeList2,Rest5} =
-%% 	case ExtensionAndException of
-%% 	    [] ->
-%% 		{AltTypeList,Rest2};
-%% 	    _ ->
-%% 		{ExtensionAddition,Rest3} =
-%% 		    case Rest2 of
-%% 			[{',',_}|Rest23] ->
-%% 			    parse_ExtensionAdditionAlternativeList(Rest23);
-%% 			_ ->
-%% 			    {[],Rest2}
-%% 		    end,
-%% 		{OptionalExtensionMarker,Rest4} =
-%% 		    case Rest3 of
-%% 			[{',',_},{'...',L3}|Rest31] ->
-%% 			    {[#'EXTENSIONMARK'{pos=L3}],Rest31};
-%% 			_ ->
-%% 			    {[],Rest3}
-%% 		    end,
-%% 		{AltTypeList ++ ExtensionAndException ++
-%% 		 ExtensionAddition ++ OptionalExtensionMarker, Rest4}
-%% 	end,
-%%     AltTypeList3 =
-%% 	case [X || X=#'EXTENSIONMARK'{} <- AltTypeList2] of
-%% 	    [] when ExtensionDefault == 'IMPLIED' ->
-%% 		AltTypeList2 ++ [#'EXTENSIONMARK'{}];
-%% 	    _ ->
-%% 		AltTypeList2
-%% 	end,
-%%     {AltTypeList3,Rest5}.
-    
-
-%% parse_AlternativeTypeList(Tokens) ->
-%%     parse_AlternativeTypeList(Tokens,[]).
-
-%% parse_AlternativeTypeList(Tokens,Acc) ->
-%%     {NamedType,Rest} = parse_NamedType(Tokens),
-%%     case Rest of
-%% 	[{',',_},Id = {identifier,_,_}|Rest2] ->
-%% 	    parse_AlternativeTypeList([Id|Rest2],[NamedType|Acc]);
-%% 	_ ->
-%% 	    {lists:reverse([NamedType|Acc]),Rest}
-%%     end.
+	    parse_error(Tokens3)
+    end;
+parse_ExtensionAdditionAlternative(Tokens) ->
+    parse_error(Tokens).
 
-    
+%%%
+%%% End of parsing of alternative type lists.
+%%%
 
-%% parse_ExtensionAdditionAlternativeList(Tokens) ->
-%%     parse_ExtensionAdditionAlternativeList(Tokens,[]).
-
-%% parse_ExtensionAdditionAlternativeList([{'[[',_}|Rest],Acc) ->
-%%     parse_ExtensionAdditionAlternativeList(Rest,Acc);
-%% parse_ExtensionAdditionAlternativeList(Tokens = [{identifier,_,_}|_Rest],Acc) ->
-%%     {Element,Rest0} = parse_NamedType(Tokens);
-%%     case Rest0 of
-%% 	[{',',_}|Rest01] ->
-%% 	    parse_ExtensionAdditionAlternativeList(Rest01,[Element|Acc]);
-%% 	_  ->
-%% 	    {lists:reverse([Element|Acc]),Rest0}
-%%     end.
-
-%% parse_ExtensionAdditionAlternatives([{'[[',_}|Rest]) ->
-%%     parse_ExtensionAdditionAlternatives(Rest,[]);
-%% parse_ExtensionAdditionAlternatives(Tokens) ->
-%%     throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-%% 		       [got,get_token(hd(Tokens)),expected,'[[']}}).
-
-%% parse_ExtensionAdditionAlternatives([Id = {identifier,_,_}|Rest],Acc) ->
-%%     {NamedType, Rest2} = parse_NamedType([Id|Rest]),
-%%     case Rest2 of
-%% 	[{',',_}|Rest21] ->
-%% 	    parse_ExtensionAdditionAlternatives(Rest21,[NamedType|Acc]);
-%% 	[{']]',_}|Rest21] ->
-%% 	    {lists:reverse(Acc),Rest21};
-%% 	_ ->
-%% 	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-%% 			       [got,get_token(hd(Rest2)),expected,[',',']]']]}})
-%%     end.
-
-parse_NamedType([{identifier,L1,Idname}|Rest]) ->
+parse_NamedType([#identifier{pos=L1,val=Idname}|Rest]) ->
     {Type,Rest2} = parse_Type(Rest),
     {#'ComponentType'{pos=L1,name=Idname,typespec=Type,prop=mandatory},Rest2};
 parse_NamedType(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,identifier]}}).
+    parse_error(Tokens).
 
+%%%
+%%% Parse component type lists for SEQUENCE and SET.
+%%%
 
 parse_ComponentTypeLists(Tokens) ->
-    parse_ComponentTypeLists(Tokens,[]).
+    parse_ComponentTypeLists(Tokens, []).
 
-parse_ComponentTypeLists(Tokens = [{identifier,_,_}|_Rest0],Clist) ->
+parse_ComponentTypeLists([#identifier{}|_Rest0]=Tokens, Clist) ->
     {CompList,Rest1} = parse_ComponentTypeList(Tokens,[]),
     parse_ComponentTypeLists(Rest1,Clist++CompList);
-parse_ComponentTypeLists(Tokens = [{'COMPONENTS',_},{'OF',_}|_Rest],Clist) ->
-    {CompList,Rest1} = parse_ComponentTypeList(Tokens,[]),
-    parse_ComponentTypeLists(Rest1,Clist++CompList);
-parse_ComponentTypeLists([{'...',L1},{'!',_}|Rest02],Clist0) ->
-    {_,Rest03} = parse_ExceptionIdentification(Rest02),
-    %% Exception info is currently thrown away
-    parse_ComponentTypeLists2(Rest03,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
+parse_ComponentTypeLists([{'COMPONENTS',_},{'OF',_}|_]=Tokens,Clist) ->
+    {CompList,Rest1} = parse_ComponentTypeList(Tokens, []),
+    parse_ComponentTypeLists(Rest1, Clist++CompList);
 parse_ComponentTypeLists([{',',L1},{'...',_},{'!',_}|Rest02],Clist0) when Clist0 =/= []->
     {_,Rest03} = parse_ExceptionIdentification(Rest02),
     %% Exception info is currently thrown away
     parse_ComponentTypeLists2(Rest03,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
-
- parse_ComponentTypeLists([{',',_},{'...',L1}|Rest02],Clist0) when Clist0 =/= []->
+parse_ComponentTypeLists([{',',_},{'...',L1}|Rest02],Clist0) when Clist0 =/= []->
     parse_ComponentTypeLists2(Rest02,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 parse_ComponentTypeLists([{'...',L1}|Rest02],Clist0) ->
     parse_ComponentTypeLists2(Rest02,Clist0++[#'EXTENSIONMARK'{pos=L1}]);
 parse_ComponentTypeLists(Tokens = [{'}',_L1}|_Rest02],Clist0) ->
-    {Clist0,Tokens}.
+    {Clist0,Tokens};
+parse_ComponentTypeLists(Tokens, _) ->
+    parse_error(Tokens).
 
 parse_ComponentTypeLists2(Tokens,Clist) ->
     {ExtAdd,Rest} = parse_ExtensionAdditions(Tokens,Clist),
@@ -2582,12 +1842,12 @@ parse_OptionalExtensionMarker(Tokens,Clist) ->
     {Clist,Tokens}.
 
 
-parse_ComponentTypeList([{',',_},Id = {identifier,_,_}|Rest],Acc) when Acc =/= [] ->
-    {ComponentType,Rest2} = parse_ComponentType([Id|Rest]),
-    parse_ComponentTypeList(Rest2,[ComponentType|Acc]);
-parse_ComponentTypeList([{',',_},C1={'COMPONENTS',_},C2={'OF',_}|Rest],Acc) when Acc =/= [] ->
-    {ComponentType,Rest2} = parse_ComponentType([C1,C2|Rest]),
-    parse_ComponentTypeList(Rest2,[ComponentType|Acc]);
+parse_ComponentTypeList([{',',_}|[#identifier{}|_]=Tokens0], Acc) when Acc =/= [] ->
+    {ComponentType,Tokens} = parse_ComponentType(Tokens0),
+    parse_ComponentTypeList(Tokens, [ComponentType|Acc]);
+parse_ComponentTypeList([{',',_}|[{'COMPONENTS',_},{'OF',_}|_]=Tokens0], Acc) when Acc =/= [] ->
+    {ComponentType,Tokens} = parse_ComponentType(Tokens0),
+    parse_ComponentTypeList(Tokens, [ComponentType|Acc]);
 parse_ComponentTypeList(Tokens = [{'}',_}|_],Acc) ->
     {lists:reverse(Acc),Tokens};
 parse_ComponentTypeList(Tokens = [{']',_},{']',_}|_],Acc) ->
@@ -2598,10 +1858,7 @@ parse_ComponentTypeList(Tokens,[]) ->
     {ComponentType,Rest} = parse_ComponentType(Tokens),
     parse_ComponentTypeList(Rest,[ComponentType]);
 parse_ComponentTypeList(Tokens,_) ->
-    throw({asn1_error,
-	   {get_line(hd(Tokens)),get(asn1_module),
-	    [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
-	     expected,['}',', identifier']]}}).
+    parse_error(Tokens).
 
 parse_ExtensionAdditions(Tokens=[{',',_}|_],Clist) ->
     {ExtAddList,Rest2} = parse_ExtensionAdditionList(Tokens,[]),
@@ -2610,46 +1867,36 @@ parse_ExtensionAdditions(Tokens,Clist) ->
     %% Empty
     {Clist,Tokens}.
 
-parse_ExtensionAdditionList([{',',_},Id = {identifier,_,_}|Rest],Acc) ->
-    {ComponentType,Rest2} = parse_ComponentType([Id|Rest]),
-    parse_ExtensionAdditionList(Rest2,[ComponentType|Acc]);
-parse_ExtensionAdditionList([{',',_},C1={'COMPONENTS',_},C2={'OF',_}|Rest],Acc) ->
-    {ComponentType,Rest2} = parse_ComponentType([C1,C2|Rest]),
-    parse_ExtensionAdditionList(Rest2,[ComponentType|Acc]);
-parse_ExtensionAdditionList([{',',_},C1 = {'[',_},C2 = {'[',_}|Rest],Acc) ->
-    {ExtAddGroup,Rest2} = parse_ExtensionAdditionGroup([C1,C2|Rest],[]),
+parse_ExtensionAdditionList([{',',_}|[#identifier{}|_]=Tokens0], Acc) ->
+    {ComponentType,Tokens} = parse_ComponentType(Tokens0),
+    parse_ExtensionAdditionList(Tokens, [ComponentType|Acc]);
+parse_ExtensionAdditionList([{',',_}|[{'COMPONENTS',_},{'OF',_}|_]=Tokens0], Acc) ->
+    {ComponentType,Tokens} = parse_ComponentType(Tokens0),
+    parse_ExtensionAdditionList(Tokens, [ComponentType|Acc]);
+parse_ExtensionAdditionList([{',',_},{'[',_},{'[',_}|Tokens], Acc) ->
+    {ExtAddGroup,Rest2} = parse_ExtensionAdditionGroup(Tokens),
     parse_ExtensionAdditionList(Rest2,[ExtAddGroup|Acc]);
-parse_ExtensionAdditionList(Tokens = [{'}',_}|_],Acc) ->
+parse_ExtensionAdditionList([{'}',_}|_]=Tokens, Acc) ->
     {lists:reverse(Acc),Tokens};
-parse_ExtensionAdditionList(Tokens = [{',',_},{'...',_}|_],Acc) ->
+parse_ExtensionAdditionList([{',',_},{'...',_}|_]=Tokens, Acc) ->
     {lists:reverse(Acc),Tokens};
-parse_ExtensionAdditionList(Tokens,_) ->
-    throw({asn1_error,
-	   {get_line(hd(Tokens)),get(asn1_module),
-	    [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
-	     expected,['}',', identifier']]}}).
-
+parse_ExtensionAdditionList(Tokens, _) ->
+    parse_error(Tokens).
 
-parse_ExtensionAdditionGroup([ {'[',_},{'[',_},_VsnNr = {number,_,Num},{':',_}|Rest],[]) ->
-    parse_ExtensionAdditionGroup2(Rest,Num);
-parse_ExtensionAdditionGroup([ {'[',_},{'[',_}|Rest],[]) ->
-    parse_ExtensionAdditionGroup2(Rest,undefined);
-parse_ExtensionAdditionGroup(Tokens,_) ->
-    throw({asn1_error,
-	   {get_line(hd(Tokens)),get(asn1_module),
-	    [got,[get_token(hd(Tokens)),get_token(hd(tl(Tokens)))],
-	     expected,['[[']]}}).
 
+parse_ExtensionAdditionGroup([{number,_,Num},{':',_}|Tokens]) ->
+    parse_ExtensionAdditionGroup2(Tokens, Num);
+parse_ExtensionAdditionGroup(Tokens) ->
+    parse_ExtensionAdditionGroup2(Tokens, undefined).
 
-parse_ExtensionAdditionGroup2(Tokens,Num) ->
+parse_ExtensionAdditionGroup2(Tokens, Num) ->
     {CompTypeList,Rest} = parse_ComponentTypeList(Tokens,[]),
     case Rest of
 	[{']',_},{']',_}|Rest2] ->
 	    {[{'ExtensionAdditionGroup',Num}|CompTypeList] ++
 		['ExtensionAdditionGroupEnd'],Rest2};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
-			       [got,get_token(hd(Rest)),expected,[']]']]}})
+	    parse_error(Rest)
     end.
 
 
@@ -2668,83 +1915,81 @@ parse_ComponentType(Tokens) ->
 	    Result
     end.
 
-	    
+%%%
+%%% Parse ENUMERATED.
+%%%
 
-parse_SignedNumber([{number,_,Value}|Rest]) ->
-    {Value,Rest};
-parse_SignedNumber([{'-',_},{number,_,Value}|Rest]) ->
-    {-Value,Rest};
-parse_SignedNumber(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,
-			[number,'-number']]}}).
-
-parse_Enumerations(Tokens=[{identifier,_,_}|_Rest],ExtensionDefault) ->
-    parse_Enumerations(Tokens,[],ExtensionDefault);
-parse_Enumerations([H|_T],_) ->
-    throw({asn1_error,{get_line(H),get(asn1_module),
-		       [got,get_token(H),expected,identifier]}}).
-
-parse_Enumerations(Tokens = [{identifier,_,_},{'(',_}|_Rest], Acc, ExtensionDefault) ->
-    {NamedNumber,Rest2} = parse_NamedNumber(Tokens),
-    case Rest2 of
-	[{',',_}|Rest3] ->
-	    parse_Enumerations(Rest3,[NamedNumber|Acc], ExtensionDefault);
-	_ when ExtensionDefault == 'IMPLIED'->
-	    {lists:reverse(['EXTENSIONMARK',NamedNumber|Acc]),Rest2};
+parse_Enumerations(Tokens0) ->
+    {Root,Tokens1} = parse_Enumeration(Tokens0),
+    case Tokens1 of
+	[{',',_},{'...',_},{',',_}|Tokens2] ->
+	    {Ext,Tokens} = parse_Enumeration(Tokens2),
+	    {Root++['EXTENSIONMARK'|Ext],Tokens};
+	[{',',_},{'...',_}|Tokens] ->
+	    {Root++['EXTENSIONMARK'],Tokens};
 	_ ->
-	    {lists:reverse([NamedNumber|Acc]),Rest2}
-    end;
-parse_Enumerations([{identifier,_,Id}|Rest], Acc, ExtensionDefault) ->
-    case Rest of
-	[{',',_}|Rest2] ->
-	    parse_Enumerations(Rest2,[Id|Acc], ExtensionDefault);
-	_ when ExtensionDefault == 'IMPLIED' ->
-	    {lists:reverse(['EXTENSIONMARK', Id |Acc]),Rest};
-	_ ->
-	    {lists:reverse([Id|Acc]),Rest}
-    end;
-parse_Enumerations([{'...',_}|Rest], Acc, _ExtensionDefault) ->
-    case Rest of
-	[{',',_}|Rest2] ->
-	    parse_Enumerations(Rest2,['EXTENSIONMARK'|Acc],undefined);
-	_ ->
-	    {lists:reverse(['EXTENSIONMARK'|Acc]),Rest}
+	    case get(extensiondefault) of
+		'IMPLIED' ->
+		    {Root++['EXTENSIONMARK'],Tokens1};
+		_ ->
+		    {Root,Tokens1}
+	    end
+    end.
+
+parse_Enumeration(Tokens0) ->
+    {Item,Tokens} = parse_EnumerationItem(Tokens0),
+    parse_Enumeration_1(Tokens, [Item]).
+
+parse_Enumeration_1([{',',_}|Tokens1]=Tokens0, Acc) ->
+    try parse_EnumerationItem(Tokens1) of
+	{Item,Tokens} ->
+	    parse_Enumeration_1(Tokens, [Item|Acc])
+    catch
+	throw:{asn1_error,_} ->
+	    {lists:reverse(Acc),Tokens0}
     end;
-parse_Enumerations([H|_T],_,_) ->
-    throw({asn1_error,{get_line(H),get(asn1_module),
-		       [got,get_token(H),expected,identifier]}}).
+parse_Enumeration_1(Tokens, Acc) ->
+    {lists:reverse(Acc),Tokens}.
+
+parse_EnumerationItem([#identifier{},{'(',_}|_]=Tokens) ->
+    parse_NamedNumber(Tokens);
+parse_EnumerationItem([#identifier{val=Id}|Tokens]) ->
+    {Id,Tokens};
+parse_EnumerationItem(Tokens) ->
+    parse_error(Tokens).
+
+%%%
+%%% End of parsing of ENUMERATED.
+%%%
 
 parse_NamedNumberList(Tokens) ->
-    parse_NamedNumberList(Tokens,[]).
+    parse_NamedNumberList(Tokens, []).
 
-parse_NamedNumberList(Tokens,Acc) ->
+parse_NamedNumberList(Tokens, Acc) ->
     {NamedNum,Rest} = parse_NamedNumber(Tokens),
     case Rest of
 	[{',',_}|Rest2] ->
 	    parse_NamedNumberList(Rest2,[NamedNum|Acc]);
 	_ ->
-	    {lists:reverse([NamedNum|Acc]),Rest}
+	    {lists:reverse(Acc, [NamedNum]),Rest}
     end.
 
-parse_NamedNumber([{identifier,_,Name},{'(',_}|Rest]) ->
+parse_NamedNumber([#identifier{val=Name},{'(',_}|Rest]) ->
     Flist = [fun parse_SignedNumber/1,
 	     fun parse_DefinedValue/1],
-    case (catch parse_or(Rest,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
+    case parse_or(Rest, Flist) of
 	{NamedNum,[{')',_}|Rest2]} ->
 	    {{'NamedNumber',Name,NamedNum},Rest2};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
-			       [got,get_token(hd(Rest)),expected,'NamedNumberList']}})
+	    parse_error(Rest)
     end;
 parse_NamedNumber(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,identifier]}}).
+    parse_error(Tokens).
 
+parse_SignedNumber([{number,_,Value}|Rest]) ->
+    {Value,Rest};
+parse_SignedNumber(Tokens) ->
+    parse_error(Tokens).
 
 parse_Tag([{'[',_}|Rest]) ->
     {Class,Rest2} = parse_Class(Rest),
@@ -2759,12 +2004,8 @@ parse_Tag([{'[',_}|Rest]) ->
 	[{']',_}|Rest4] ->
 	    {#tag{class=Class,number=ClassNumber},Rest4};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest3)),get(asn1_module),
-			       [got,get_token(hd(Rest3)),expected,']']}})
-    end;
-parse_Tag(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'[']}}).
+	    parse_error(Rest3)
+    end.
 
 parse_Class([{'UNIVERSAL',_}|Rest]) ->
     {'UNIVERSAL',Rest};
@@ -2783,15 +2024,7 @@ parse_Value(Tokens) ->
     Flist = [fun parse_BuiltinValue/1,
 	     fun parse_ValueFromObject/1,
 	     fun parse_DefinedValue/1],
-
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end.
+    parse_or(Tokens, Flist).
 
 parse_BuiltinValue([{bstring,_,Bstr}|Rest]) ->
     {{bstring,Bstr},Rest};
@@ -2804,18 +2037,11 @@ parse_BuiltinValue(Tokens = [{'{',_}|_Rest]) ->
 	     fun parse_SequenceOfValue/1, 
 	     fun parse_SequenceValue/1, 
 	     fun parse_ObjectIdentifierValue/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	Result ->
-	    Result
-    end;
-parse_BuiltinValue([{identifier,_,IdName},{':',_}|Rest]) ->
+    parse_or(Tokens, Flist);
+parse_BuiltinValue([#identifier{val=IdName},{':',_}|Rest]) ->
     {Value,Rest2} = parse_Value(Rest),
     {{'CHOICE',{IdName,Value}},Rest2};
-parse_BuiltinValue(Tokens=[{'NULL',_},{':',_}|_Rest])  ->
+parse_BuiltinValue([{'NULL',_},{':',_}|_]=Tokens)  ->
     parse_ObjectClassFieldValue(Tokens);
 parse_BuiltinValue([{'NULL',_}|Rest])  ->
     {'NULL',Rest};
@@ -2831,50 +2057,44 @@ parse_BuiltinValue([{cstring,_,Cstr}|Rest]) ->
     {Cstr,Rest};
 parse_BuiltinValue([{number,_,Num}|Rest]) ->
     {Num,Rest};
-parse_BuiltinValue([{'-',_},{number,_,Num}|Rest]) ->
-    {- Num,Rest};
 parse_BuiltinValue(Tokens) ->
     parse_ObjectClassFieldValue(Tokens).
 
-parse_DefinedValue(Tokens=[{identifier,_,_},{'{',_}|_Rest]) ->
-    parse_ParameterizedValue(Tokens);
-%% Externalvaluereference
-parse_DefinedValue([{typereference,L1,Tname},{'.',_},{identifier,_,Idname}|Rest]) ->
+parse_DefinedValue(Tokens) ->
+    Flist = [fun parse_ParameterizedValue/1,
+	     fun parse_DefinedValue2/1],
+    parse_or(Tokens, Flist).
+
+parse_DefinedValue2([{typereference,L1,Tname},
+		     {'.',_},
+		     #identifier{val=Idname}|Rest]) ->
     {#'Externalvaluereference'{pos=L1,module=Tname,value=Idname},Rest};
 %% valuereference
-parse_DefinedValue([Id = {identifier,_,_}|Rest]) ->
+parse_DefinedValue2([#identifier{}=Id|Rest]) ->
     {identifier2Extvalueref(Id),Rest};
-%% ParameterizedValue
-parse_DefinedValue(Tokens) ->
-    parse_ParameterizedValue(Tokens).
+parse_DefinedValue2(Tokens) ->
+    parse_error(Tokens).
 
 
 parse_SequenceValue([{'{',_}|Tokens]) ->
-    parse_SequenceValue(Tokens,[]);
-parse_SequenceValue(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'{']}}).
+    parse_SequenceValue(Tokens, []).
 
-parse_SequenceValue([{identifier,_,IdName}|Rest],Acc) ->
+parse_SequenceValue([#identifier{pos=Pos,val=IdName}|Rest],Acc) ->
     {Value,Rest2} = parse_Value(Rest),
+    SeqTag = #seqtag{pos=Pos,module=get(asn1_module),val=IdName},
     case Rest2 of
 	[{',',_}|Rest3] ->
-	    parse_SequenceValue(Rest3,[{IdName,Value}|Acc]);
+	    parse_SequenceValue(Rest3, [{SeqTag,Value}|Acc]);
 	[{'}',_}|Rest3] ->
-	    {lists:reverse([{IdName,Value}|Acc]),Rest3};
+	    {lists:reverse(Acc, [{SeqTag,Value}]),Rest3};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,'}']}})
+	    parse_error(Rest2)
     end;
 parse_SequenceValue(Tokens,_Acc) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,identifier]}}).
+    parse_error(Tokens).
 
 parse_SequenceOfValue([{'{',_}|Tokens]) ->
-    parse_SequenceOfValue(Tokens,[]);
-parse_SequenceOfValue(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'{']}}).
+    parse_SequenceOfValue(Tokens, []).
 
 parse_SequenceOfValue(Tokens,Acc) ->
     {Value,Rest2} = parse_Value(Tokens),
@@ -2882,10 +2102,9 @@ parse_SequenceOfValue(Tokens,Acc) ->
 	[{',',_}|Rest3] ->
 	    parse_SequenceOfValue(Rest3,[Value|Acc]);
 	[{'}',_}|Rest3] ->
-	    {lists:reverse([Value|Acc]),Rest3};
+	    {lists:reverse(Acc, [Value]),Rest3};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,'}']}})
+	    parse_error(Rest2)
     end.
 
 parse_ValueSetTypeAssignment([{typereference,L1,Name}|Rest]) ->
@@ -2895,49 +2114,31 @@ parse_ValueSetTypeAssignment([{typereference,L1,Name}|Rest]) ->
 	    {ValueSet,Rest4} = parse_ValueSet(Rest3),
 	    {#valuedef{pos=L1,name=Name,type=Type,value=ValueSet,
 		       module=get(asn1_module)},Rest4};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(L1),get(asn1_module),
-			       [got,get_token(H),expected,'::=']}})
-    end;
-parse_ValueSetTypeAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,
-				   typereference]}}).
+	_ ->
+	    parse_error(Rest2)
+    end.
 
 parse_ValueSet([{'{',_}|Rest]) ->
     {Elems,Rest2} = parse_ElementSetSpecs(Rest),
     case Rest2 of
 	[{'}',_}|Rest3] ->
 	    {{valueset,Elems},Rest3};
-	[H|_T] ->
-	    throw({asn1_error,{get_line(H),get(asn1_module),
-			       [got,get_token(H),expected,'}']}})
+	_ ->
+	    parse_error(Rest2)
     end;
 parse_ValueSet(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'{']}}).
+    parse_error(Tokens).
 
-parse_ValueAssignment([{identifier,L1,IdName}|Rest]) ->
+parse_ValueAssignment([#identifier{pos=L1,val=IdName}|Rest]) ->
     {Type,Rest2} = parse_Type(Rest),
     case Rest2 of
 	[{'::=',_}|Rest3] ->
 	    {Value,Rest4} = parse_Value(Rest3),
-	    case catch lookahead_assignment(Rest4) of
-		ok ->
-		    {#valuedef{pos=L1,name=IdName,type=Type,value=Value,
-			       module=get(asn1_module)},Rest4};
-		Error ->
-		    throw(Error)
-%% 		    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-%% 				       [got,get_token(hd(Rest2)),expected,'::=']}})
-	    end;
+	    {#valuedef{pos=L1,name=IdName,type=Type,value=Value,
+		       module=get(asn1_module)},Rest4};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest2)),get(asn1_module),
-			       [got,get_token(hd(Rest2)),expected,'::=']}})
-    end;
-parse_ValueAssignment(Tokens) ->
-    throw({asn1_assignment_error,{get_line(hd(Tokens)),get(asn1_module),
-				  [got,get_token(hd(Tokens)),expected,identifier]}}).
+	    parse_error(Rest2)
+    end.
 
 %% SizeConstraint
 parse_SubtypeElements([{'SIZE',_}|Tokens]) ->
@@ -2957,8 +2158,7 @@ parse_SubtypeElements([{'WITH',_},{'COMPONENTS',_},{'{',_},{'...',_},{',',_}|Tok
 	[{'}',_}|Rest2] ->
 	    {{'WITH COMPONENTS',{'PartialSpecification',Constraint}},Rest2};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
-			       [got,get_token(hd(Rest)),expected,'}']}})
+	    parse_error(Rest)
     end;
 parse_SubtypeElements([{'WITH',_},{'COMPONENTS',_},{'{',_}|Tokens]) ->
     {Constraint,Rest} = parse_TypeConstraints(Tokens),
@@ -2966,28 +2166,18 @@ parse_SubtypeElements([{'WITH',_},{'COMPONENTS',_},{'{',_}|Tokens]) ->
 	[{'}',_}|Rest2] ->
 	    {{'WITH COMPONENTS',{'FullSpecification',Constraint}},Rest2};
 	_ ->
-	    throw({asn1_error,{get_line(hd(Rest)),get(asn1_module),
-			       [got,get_token(hd(Rest)),expected,'}']}})
+	    parse_error(Rest)
     end;
 parse_SubtypeElements([{'PATTERN',_}|Tokens]) ->
     {Value,Rest} = parse_Value(Tokens),
     {{pattern,Value},Rest};
-%% SingleValue
-%% ContainedSubtype
-%% ValueRange
-%% TypeConstraint
-%% Moved fun parse_Value/1 and fun parse_Type/1 to parse_Elements
 parse_SubtypeElements(Tokens) ->
     Flist = [fun parse_ContainedSubtype/1,
 	     fun parse_Value/1, 
-	     fun([{'MIN',_}|T]) -> {'MIN',T} end,
+	     fun parse_MIN/1,
 	     fun parse_Type/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	{asn1_error,Reason} ->
-	    throw(Reason);
-	Result = {Val,_} when is_record(Val,type) ->
+    case parse_or(Tokens, Flist) of
+	{#type{},_}=Result ->
 	    Result;
 	{Lower,[{'..',_}|Rest]} ->
 	    {Upper,Rest2} = parse_UpperEndpoint(Rest),
@@ -3005,10 +2195,7 @@ parse_ContainedSubtype([{'INCLUDES',_}|Rest]) ->
     {Type,Rest2} = parse_Type(Rest),
     {{'ContainedSubtype',Type},Rest2};
 parse_ContainedSubtype(Tokens) ->
-    throw({asn1_error,{get_line(hd(Tokens)),get(asn1_module),
-		       [got,get_token(hd(Tokens)),expected,'INCLUDES']}}).
-%%parse_ContainedSubtype(Tokens) -> %this option is moved to parse_SubtypeElements
-%%    parse_Type(Tokens).
+    parse_error(Tokens).
 
 parse_UpperEndpoint([{'<',_}|Rest]) ->
     parse_UpperEndpoint(lt,Rest);
@@ -3016,33 +2203,38 @@ parse_UpperEndpoint(Tokens) ->
     parse_UpperEndpoint(false,Tokens).
 
 parse_UpperEndpoint(Lt,Tokens) ->
-    Flist = [ fun([{'MAX',_}|T]) -> {'MAX',T} end,
-	      fun parse_Value/1],
-    case (catch parse_or(Tokens,Flist)) of
-	{'EXIT',Reason} ->
-	    exit(Reason);
-	AsnErr = {asn1_error,_} ->
-	    throw(AsnErr);
-	{Value,Rest2} when Lt == lt ->
+    Flist = [fun parse_MAX/1,
+	     fun parse_Value/1],
+    case parse_or(Tokens, Flist) of
+	{Value,Rest2} when Lt =:= lt ->
 	    {{lt,Value},Rest2};
 	{Value,Rest2} ->
 	    {Value,Rest2}
     end.
 
+parse_MIN([{'MIN',_}|T]) ->
+    {'MIN',T};
+parse_MIN(Tokens) ->
+    parse_error(Tokens).
+
+parse_MAX([{'MAX',_}|T]) ->
+    {'MAX',T};
+parse_MAX(Tokens) ->
+    parse_error(Tokens).
+
 parse_TypeConstraints(Tokens) ->
-    parse_TypeConstraints(Tokens,[]).
+    parse_TypeConstraints(Tokens, []).
 
-parse_TypeConstraints([{identifier,_,_}|Rest],Acc) ->
+parse_TypeConstraints([#identifier{}|Rest], Acc) ->
     {ComponentConstraint,Rest2} = parse_ComponentConstraint(Rest),
     case Rest2 of
 	[{',',_}|Rest3] ->
-	    parse_TypeConstraints(Rest3,[ComponentConstraint|Acc]);
+	    parse_TypeConstraints(Rest3, [ComponentConstraint|Acc]);
 	_ ->
-	    {lists:reverse([ComponentConstraint|Acc]),Rest2}
+	    {lists:reverse(Acc, [ComponentConstraint]),Rest2}
     end;
-parse_TypeConstraints([H|_T],_) ->
-    throw({asn1_error,{get_line(H),get(asn1_module),
-		       [got,get_token(H),expected,identifier]}}).
+parse_TypeConstraints(Tokens, _) ->
+    parse_error(Tokens).
 
 parse_ComponentConstraint(Tokens = [{'(',_}|_Rest]) ->
     {ValueConstraint,Rest2} = parse_Constraint(Tokens),
@@ -3062,145 +2254,36 @@ parse_PresenceConstraint(Tokens) ->
     {asn1_empty,Tokens}.
 
 
-% merge_constraints({Rlist,ExtList}) -> % extensionmarker in constraint
-%     {merge_constraints(Rlist,[],[]),
-%      merge_constraints(ExtList,[],[])};
-
-%% An arg with a constraint with extension marker will look like
-%% [#constraint{c={Root,Ext}}|Rest]
-	
 merge_constraints(Clist) ->
     merge_constraints(Clist, [], []).
 
-merge_constraints([Ch|Ct],Cacc, Eacc) ->
-    NewEacc = case Ch#constraint.e of
-		  undefined -> Eacc;
-		  E -> [E|Eacc]
-	      end,
-    merge_constraints(Ct,[fixup_constraint(Ch#constraint.c)|Cacc],NewEacc);
-
-merge_constraints([],Cacc,[]) ->
-%%    lists:flatten(Cacc);
+merge_constraints([#constraint{c=C,e=E}|T], Cacc0, Eacc0) ->
+    Eacc = case E of
+	       undefined -> Eacc0;
+	       E -> [E|Eacc0]
+	   end,
+    Cacc = [C|Cacc0],
+    merge_constraints(T, Cacc, Eacc);
+merge_constraints([], Cacc, []) ->
     lists:reverse(Cacc);
-merge_constraints([],Cacc,Eacc) ->
-%%    lists:flatten(Cacc) ++ [{'Errors',Eacc}].
-    lists:reverse(Cacc) ++ [{'Errors',Eacc}].
-
-
-fixup_constraint(C) ->
-    case C of
-	{'SingleValue',SubType} when element(1,SubType) == 'ContainedSubtype' ->
-	    SubType;
-	{'SingleValue',V} when is_list(V) ->
-	    C;
-	%%	    [C,{'ValueRange',{lists:min(V),lists:max(V)}}]; 
-	%% bug, turns wrong when an element in V is a reference to a defined value
-	{'PermittedAlphabet',{'SingleValue',V}} when is_list(V) ->
-	    %%sort and remove duplicates
-	    V2 = {'SingleValue',
-		  ordsets:from_list(lists:flatten(V))},
-	    {'PermittedAlphabet',V2};
-	{'PermittedAlphabet',{'SingleValue',V}} ->
-	    V2 = {'SingleValue',[V]},
-	    {'PermittedAlphabet',V2};
-	{'SizeConstraint',Sc} ->
-	    {'SizeConstraint',fixup_size_constraint(Sc)};
-	
-	List when is_list(List) ->  %% In This case maybe a union or intersection
-	    [fixup_constraint(Xc)||Xc <- List];
-	Other ->
-	    Other
-    end.
+merge_constraints([], Cacc, Eacc) ->
+    lists:reverse(Cacc) ++ [{element_set,{'Errors',Eacc},none}].
 
-fixup_size_constraint({'ValueRange',{Lb,Ub}}) ->
-	{Lb,Ub};
-fixup_size_constraint({{'ValueRange',R},[]}) ->
-	{R,[]};
-fixup_size_constraint({[],{'ValueRange',R}}) ->
-	{[],R};
-fixup_size_constraint({{'ValueRange',R1},{'ValueRange',R2}}) ->
-	{R1,R2};
-fixup_size_constraint({'SingleValue',[Sv]}) ->
-	fixup_size_constraint({'SingleValue',Sv});
-fixup_size_constraint({'SingleValue',L}) when is_list(L) ->
-	ordsets:from_list(L);
-fixup_size_constraint({'SingleValue',L}) ->
-	{L,L};
-fixup_size_constraint({'SizeConstraint',C}) ->
-    %% this is a second SIZE
-    fixup_size_constraint(C);
-fixup_size_constraint({C1,C2}) ->
-    %% this is with extension marks
-    {turn2vr(fixup_size_constraint(C1)), extension_size(fixup_size_constraint(C2))};
-fixup_size_constraint(CList) when is_list(CList) ->
-    [fixup_constraint(Xc)||Xc <- CList].
-   
-turn2vr(L) when is_list(L) ->
-    L2 =[X||X<-ordsets:from_list(L),is_integer(X)],
-    case L2 of
-	[H|_] ->
-	    {H,hd(lists:reverse(L2))};
-	_ ->
-	    L
-    end;
-turn2vr(VR) ->
-    VR.
-extension_size({I,I}) ->
-    [I];
-extension_size({I1,I2}) ->
-    [I1,I2];
-extension_size(C) ->
-    C.
-
-get_line({_,Pos,Token}) when is_integer(Pos),is_atom(Token) ->
+get_line({Token,Pos,_}) when is_integer(Pos), is_atom(Token) ->
     Pos;
 get_line({Token,Pos}) when is_integer(Pos),is_atom(Token) ->
-    Pos;
-get_line(_) ->
-    undefined.
-
-get_token({_,Pos,Token}) when is_integer(Pos),is_atom(Token) ->
-    Token;
+    Pos.
+
+get_token({valuefieldreference,_,FieldName}) ->
+    list_to_atom([$&|atom_to_list(FieldName)]);
+get_token({typefieldreference,_,FieldName}) ->
+    list_to_atom([$&|atom_to_list(FieldName)]);
+get_token({Token,Pos,Value}) when is_integer(Pos), is_atom(Token) ->
+    Value;
 get_token({'$end',Pos}) when is_integer(Pos) ->
-    undefined;
+    'END-OF-FILE';
 get_token({Token,Pos}) when is_integer(Pos),is_atom(Token) ->
-    Token;
-get_token(_) ->
-    undefined.
-
-prioritize_error(ErrList) ->
-    case lists:keymember(asn1_error,1,ErrList) of
-	false -> % only asn1_assignment_error -> take the last
-	    lists:last(ErrList);
-	true -> % contains errors from deeper in a Type
-	    NewErrList = [_Err={_,_}|_RestErr] =
-		lists:filter(fun({asn1_error,_})->true;(_)->false end,
-			     ErrList),
-	    SplitErrs =
-		lists:splitwith(fun({_,X})->
-					case element(1,X) of
-					    Int when is_integer(Int) -> true;
-					    _ -> false
-					end
-				end,
-				NewErrList),
-	    case SplitErrs of
-		{[],UndefPosErrs} -> % if no error with Positon exists
-		    lists:last(UndefPosErrs);
-		{IntPosErrs,_} ->
-		    IntPosReasons = lists:map(fun(X)->element(2,X) end,IntPosErrs),
-		    SortedReasons = lists:keysort(1,IntPosReasons),
-		    {asn1_error,lists:last(SortedReasons)}
-	    end
-    end.
-
-%% most_prio_error([H={_,Reason}|T],Atom,Err) when is_atom(Atom) ->
-%%     most_prio_error(T,element(1,Reason),H);
-%% most_prio_error([H={_,Reason}|T],Greatest,Err) ->
-%%     case element(1,Reason) of
-%% 	Pos when is_integer(Pos),Pos>Greatest ->
-%% 	    most_prio_error(
-
+    Token.
 
 tref2Exttref(#typereference{pos=Pos,val=Name}) ->
     #'Externaltypereference'{pos=Pos,
@@ -3217,19 +2300,5 @@ identifier2Extvalueref(#identifier{pos=Pos,val=Name}) ->
 			      module=resolve_module(Name),
 			      value=Name}.
 
-%% lookahead_assignment/1 checks that the next sequence of tokens
-%% in Token contain a valid assignment or the
-%% 'END' token. Otherwise an exception is thrown.
-lookahead_assignment([{'END',_}|_Rest]) ->
-    ok;
-lookahead_assignment(Tokens) ->
-    parse_Assignment(Tokens),
-    ok.
-	
-is_pre_defined_class('TYPE-IDENTIFIER') ->
-    true;
-is_pre_defined_class('ABSTRACT-SYNTAX') ->
-    true;
-is_pre_defined_class(_) ->
-    false.
-    
+parse_error(Tokens) ->
+    throw({asn1_error,{parse_error,Tokens}}).
diff --git a/lib/asn1/src/asn1ct_pretty_format.erl b/lib/asn1/src/asn1ct_pretty_format.erl
index a01c1db8c5..f4669f7eb0 100644
--- a/lib/asn1/src/asn1ct_pretty_format.erl
+++ b/lib/asn1/src/asn1ct_pretty_format.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %% 
 %% %CopyrightEnd%
 %%
diff --git a/lib/asn1/src/asn1ct_table.erl b/lib/asn1/src/asn1ct_table.erl
index a5eb6d0413..1a3a81d329 100644
--- a/lib/asn1/src/asn1ct_table.erl
+++ b/lib/asn1/src/asn1ct_table.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -22,34 +23,25 @@
 %% Table abstraction module for ASN.1 compiler
 
 -export([new/1]).
--export([new/2]).
 -export([new_reuse/1]).
--export([new_reuse/2]).
 -export([exists/1]).
 -export([size/1]).
 -export([insert/2]).
 -export([lookup/2]).
 -export([match/2]).
 -export([to_list/1]).
--export([delete/1]). % TODO: Remove (since we run in a separate process)
+-export([delete/1]).
 
 
-%% Always creates a new table
-new(Table) -> new(Table, []).
-new(Table, Options) ->
-    TableId = case get(Table) of
-                undefined ->
-                    ets:new(Table, Options);
-                _  ->
-                    delete(Table),
-                    ets:new(Table, Options)
-              end,
+%% Always create a new table.
+new(Table) ->
+    undefined = get(Table),			%Assertion.
+    TableId = ets:new(Table, []),
     put(Table, TableId).
 
-%% Only create it if it doesn't exist yet
-new_reuse(Table) -> new_reuse(Table, []).
-new_reuse(Table, Options) ->
-    not exists(Table) andalso new(Table, Options).
+%% Only create it if it doesn't exist yet.
+new_reuse(Table) ->
+    not exists(Table) andalso new(Table).
 
 exists(Table) -> get(Table) =/= undefined.
 
@@ -63,14 +55,17 @@ match(Table, MatchSpec) -> ets:match(get(Table), MatchSpec).
 
 to_list(Table) -> ets:tab2list(get(Table)).
 
+%% Deleting tables is no longer strictly necessary since each compilation
+%% runs in separate process, but it will reduce memory consumption
+%% especially when many compilations are run in parallel.
+
 delete(Tables) when is_list(Tables) ->
     [delete(T) || T <- Tables],
     true;
 delete(Table) when is_atom(Table) ->
-    case get(Table) of
+    case erase(Table) of
         undefined ->
             true;
         TableId ->
-            ets:delete(TableId),
-            erase(Table)
+            ets:delete(TableId)
     end.
diff --git a/lib/asn1/src/asn1ct_tok.erl b/lib/asn1/src/asn1ct_tok.erl
index 85199c65ec..8235b689f8 100644
--- a/lib/asn1/src/asn1ct_tok.erl
+++ b/lib/asn1/src/asn1ct_tok.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2010. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -21,191 +22,177 @@
 
 %% Tokenize ASN.1 code (input to parser generated with yecc)   
 
--export([get_name/2,tokenise/4, file/1]).
-
+-export([file/1,format_error/1]).
 
-file(File) ->
-    case file:open(File, [read])  of
+file(File0) ->
+    case file:open(File0, [read])  of
 	{error, Reason} ->
-	    {error,{File,file:format_error(Reason)}};
+	    {error,{File0,file:format_error(Reason)}};
 	{ok,Stream} ->
-	    process(Stream,0,[])
+	    try
+		process(Stream, 1, [])
+	    catch
+		throw:{error,Line,Reason} ->
+		    File = filename:basename(File0),
+		    Error = {structured_error,{File,Line},?MODULE,Reason},
+		    {error,[Error]}
+	    end
     end.
 
-process(Stream,Lno,R) ->
-    process(io:get_line(Stream, ''), Stream,Lno+1,R).
-
-process(eof, Stream,Lno,R) ->
-    file:close(Stream),
-    lists:flatten(lists:reverse([{'$end',Lno}|R]));
-
-
-process(L, Stream,Lno,R) when is_list(L) ->
-    %%io:format('read:~s',[L]),
-    case catch tokenise(Stream,L,Lno,[]) of
-	{'ERR',Reason} ->
-	    io:format("Tokeniser error on line: ~w ~w~n",[Lno,Reason]),
-	    exit(0);
-	{NewLno,T} ->
-	    %%io:format('toks:~w~n',[T]),
-	    process(Stream,NewLno,[T|R])
-    end. 
-
-tokenise(Stream,[H|T],Lno,R) when $a =< H , H =< $z ->
-    {X, T1} = get_name(T, [H]),
-    tokenise(Stream,T1,Lno,[{identifier,Lno, list_to_atom(X)}|R]);
-
-tokenise(Stream,[$&,H|T],Lno,R) when $A =< H , H =< $Z ->
-    {Y, T1} = get_name(T, [H]),
-    X = list_to_atom(Y),
-    tokenise(Stream,T1,Lno,[{typefieldreference, Lno, X} | R]);
-
-tokenise(Stream,[$&,H|T],Lno,R) when $a =< H , H =< $z ->
-    {Y, T1} = get_name(T, [H]),
-    X = list_to_atom(Y),
-    tokenise(Stream,T1,Lno,[{valuefieldreference, Lno, X} | R]);
-
-tokenise(Stream,[H|T],Lno,R) when $A =< H , H =< $Z ->
-    {Y, T1} = get_name(T, [H]),
-    X = list_to_atom(Y),
-    case reserved_word(X) of
-	true ->
-	    tokenise(Stream,T1,Lno,[{X,Lno}|R]);
-	false ->
-	    tokenise(Stream,T1,Lno,[{typereference,Lno,X}|R]);
-	rstrtype ->
-	    tokenise(Stream,T1,Lno,[{restrictedcharacterstringtype,Lno,X}|R])
-    end;
-
-tokenise(Stream,[$-,H|T],Lno,R) when $0 =< H , H =< $9 ->
-    {X, T1} = get_number(T, [H]),
-    tokenise(Stream,T1,Lno,[{number,Lno,-1 * list_to_integer(X)}|R]);
+process(Stream, Lno, R) ->
+    process(io:get_line(Stream, ''), Stream, Lno, R).
+
+process(eof, Stream, Lno, Acc) ->
+    ok = file:close(Stream),
+    lists:reverse([{'$end',Lno}|Acc]);
+process(L, Stream, Lno0, Acc) when is_list(L) ->
+    try tokenise(Stream, L, Lno0, []) of
+	{Lno,[]} ->
+	    process(Stream, Lno, Acc);
+	{Lno,Ts} ->
+	    process(Stream, Lno, Ts++Acc)
+    catch
+	throw:{error,Reason} ->
+	    throw({error,Lno0,Reason})
+    end.
 
-tokenise(Stream,[H|T],Lno,R) when $0 =< H , H =< $9 ->
+format_error(eof_in_comment) ->
+    "premature end of file in multi-line comment";
+format_error(eol_in_token) ->
+    "end of line in token";
+format_error({invalid_binary_number,Str}) ->
+    io_lib:format("invalid binary number: '~s'", [Str]);
+format_error({invalid_hex_number,Str}) ->
+    io_lib:format("invalid hex number: '~s'", [Str]);
+format_error(Other) ->
+    io_lib:format("~p", [Other]).
+
+tokenise(Stream, [$&,H|T], Lno, R) when $A =< H , H =< $Z ->
+    {X,T1} = get_name(T, [H]),
+    tokenise(Stream, T1, Lno, [{typefieldreference,Lno,X}|R]);
+tokenise(Stream, [$&,H|T], Lno, R) when $a =< H , H =< $z ->
+    {X,T1} = get_name(T, [H]),
+    tokenise(Stream, T1, Lno, [{valuefieldreference,Lno,X}|R]);
+
+tokenise(Stream, "--"++T, Lno, R) ->
+    tokenise(Stream, skip_comment(T), Lno, R);
+
+tokenise(Stream, [$-,H|T], Lno, R) when $0 =< H , H =< $9 ->
     {X, T1} = get_number(T, [H]),
-    tokenise(Stream,T1,Lno,[{number,Lno,list_to_integer(X)}|R]);
-
-tokenise(Stream,[$-,$-|T],Lno,R) ->
-    tokenise(Stream,skip_comment(T),Lno,R);
-
-tokenise(Stream,[$/,$*|T],Lno,R) ->
-    {NewLno,T1} = skip_multiline_comment(Stream,T,Lno,0),
-    tokenise(Stream,T1,NewLno,R);
+    tokenise(Stream, T1, Lno, [{number,Lno,-list_to_integer(X)}|R]);
 
-tokenise(Stream,[$:,$:,$=|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'::=',Lno}|R]);
+tokenise(Stream, "/*"++T, Lno0, R) ->
+    {Lno,T1} = skip_multiline_comment(Stream, T, Lno0, 0),
+    tokenise(Stream, T1, Lno, R);
 
-tokenise(Stream,[$'|T],Lno,R) ->
-    case catch collect_quoted(T,Lno,[]) of
-         {'ERR',_} ->
-             throw({'ERR','bad_quote'});
-         {Thing, T1} ->
-             tokenise(Stream,T1,Lno,[Thing|R])
-    end;
+tokenise(Stream, "::="++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{'::=',Lno}|R]);
+tokenise(Stream, ":"++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{':',Lno}|R]);
 
+tokenise(Stream, "'"++T0, Lno, R) ->
+    {Thing, T1} = collect_quoted(T0, Lno, []),
+    tokenise(Stream, T1, Lno, [Thing|R]);
 tokenise(Stream,[$"|T],Lno,R) ->
     {Str,T1} = collect_string(T,Lno),
     tokenise(Stream,T1,Lno,[Str|R]);
 
-tokenise(Stream,[${|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'{',Lno}|R]);
-
-tokenise(Stream,[$}|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'}',Lno}|R]);
-
-%% tokenise(Stream,[$],$]|T],Lno,R) ->
-%%     tokenise(Stream,T,Lno,[{']]',Lno}|R]);
+tokenise(Stream, "{"++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{'{',Lno}|R]);
+tokenise(Stream, "}"++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{'}',Lno}|R]);
 
 %% Even though x.680 specify '[[' and ']]' as lexical items
-%% it does not work to have them as such since the single [ and ] can
-%% be used beside each other in the SYNTAX OF in x.681
-%% the solution chosen here , i.e. to have them as separate lexical items
+%% it does not work to have them as such since the single '[' and ']' can
+%% be used beside each other in 'WITH SYNTAX' in x.681.
+%% The solution chosen here, i.e. to have them as separate lexical items
 %% will not detect the cases where there is white space between them
-%% which would be an error in the use in ExtensionAdditionGroups
-
-%% tokenise(Stream,[$[,$[|T],Lno,R) ->
-%%     tokenise(Stream,T,Lno,[{'[[',Lno}|R]);
-
-tokenise(Stream,[$]|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{']',Lno}|R]);
+%% which would be an error in the use in ExtensionAdditionGroups.
 
-tokenise(Stream,[$[|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'[',Lno}|R]);
+tokenise(Stream, "]"++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{']',Lno}|R]);
+tokenise(Stream, "["++T,Lno,R) ->
+    tokenise(Stream, T, Lno, [{'[',Lno}|R]);
 
-tokenise(Stream,[$,|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{',',Lno}|R]);
+tokenise(Stream, ","++T,Lno,R) ->
+    tokenise(Stream, T, Lno, [{',',Lno}|R]);
 
-tokenise(Stream,[$(|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'(',Lno}|R]);
-tokenise(Stream,[$)|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{')',Lno}|R]);
+tokenise(Stream, "("++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{'(',Lno}|R]);
+tokenise(Stream, ")"++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{')',Lno}|R]);
 
-tokenise(Stream,[$.,$.,$.|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'...',Lno}|R]);
+tokenise(Stream, "..."++T,Lno,R) ->
+    tokenise(Stream, T, Lno, [{'...',Lno}|R]);
+tokenise(Stream, ".."++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{'..',Lno}|R]);
+tokenise(Stream, "."++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{'.',Lno}|R]);
 
-tokenise(Stream,[$.,$.|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'..',Lno}|R]);
+tokenise(Stream, "|"++T, Lno, R) ->
+    tokenise(Stream, T, Lno, [{'|',Lno}|R]);
 
-tokenise(Stream,[$.|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'.',Lno}|R]);
-tokenise(Stream,[$^|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'^',Lno}|R]);
-tokenise(Stream,[$!|T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'!',Lno}|R]);
-tokenise(Stream,[$||T],Lno,R) ->
-    tokenise(Stream,T,Lno,[{'|',Lno}|R]);
-
-tokenise(Stream,[H|T],Lno,R) ->
-    case white_space(H) of
+tokenise(Stream, [H|T], Lno, R) when $A =< H , H =< $Z ->
+    {X,T1} = get_name(T, [H]),
+    case reserved_word(X) of
 	true ->
-	    tokenise(Stream,T,Lno,R);
+	    tokenise(Stream, T1, Lno, [{X,Lno}|R]);
 	false ->
-	    tokenise(Stream,T,Lno,[{list_to_atom([H]),Lno}|R])
+	    tokenise(Stream, T1, Lno, [{typereference,Lno,X}|R]);
+	rstrtype ->
+	    tokenise(Stream, T1, Lno, [{restrictedcharacterstringtype,Lno,X}|R])
     end;
-tokenise(_Stream,[],Lno,R) ->
-    {Lno,lists:reverse(R)}.
 
+tokenise(Stream, [H|T], Lno, R) when $a =< H , H =< $z ->
+    {X, T1} = get_name(T, [H]),
+    tokenise(Stream, T1, Lno, [{identifier,Lno,X}|R]);
+
+tokenise(Stream, [H|T], Lno, R) when $0 =< H , H =< $9 ->
+    {X, T1} = get_number(T, [H]),
+    tokenise(Stream, T1, Lno, [{number,Lno,list_to_integer(X)}|R]);
 
-collect_string(L,Lno) ->
-    collect_string(L,Lno,[]).
+tokenise(Stream, [H|T], Lno, R) when H =< $\s ->
+    tokenise(Stream, T, Lno, R);
 
-collect_string([],_,_) ->
-    throw({'ERR','bad_quote found eof'});
+tokenise(Stream, [H|T], Lno, R) ->
+    tokenise(Stream, T, Lno, [{list_to_atom([H]),Lno}|R]);
+tokenise(_Stream, [], Lno, R) ->
+    {Lno+1,R}.
 
-collect_string([H|T],Lno,Str) ->
-    case H of
-	$" ->
-           {{cstring,1,lists:reverse(Str)},T};
-        Ch ->
-           collect_string(T,Lno,[Ch|Str])
-    end.
-           
 
+collect_string(L, Lno) ->
+    collect_string(L, Lno, []).
 
-% <name> is letters digits hyphens
-% hypen is not the last character. Hypen hyphen is NOT allowed
-%
-% <identifier> ::= <lowercase> <name>
+collect_string([$"|T], _Lno, Str) ->
+    {{cstring,1,lists:reverse(Str)},T};
+collect_string([H|T], Lno, Str) ->
+    collect_string(T, Lno, [H|Str]);
+collect_string([], _, _) ->
+    throw({error,missing_quote_at_eof}).
+           
+%% <name> is letters digits hyphens.
+%% Hypen is not the last character. Hypen hyphen is NOT allowed.
+%%
+%% <identifier> ::= <lowercase> <name>
 
-get_name([$-,Char|T], L) ->
+get_name([$-,Char|T]=T0, Acc) ->
     case isalnum(Char) of
 	true ->
-	    get_name(T,[Char,$-|L]);
+	    get_name(T, [Char,$-|Acc]);
 	false ->
-	    {lists:reverse(L),[$-,Char|T]}
+	    {list_to_atom(lists:reverse(Acc)),T0}
     end;
-get_name([$-|T], L) ->
-    {lists:reverse(L),[$-|T]};
-get_name([Char|T], L) ->
+get_name([$-|_]=T, Acc) ->
+    {list_to_atom(lists:reverse(Acc)),T};
+get_name([Char|T]=T0, Acc) ->
     case isalnum(Char) of
 	true ->
-	    get_name(T,[Char|L]);
+	    get_name(T, [Char|Acc]);
 	false ->
-	    {lists:reverse(L),[Char|T]}
+	    {list_to_atom(lists:reverse(Acc)),T0}
     end;
-get_name([], L) ->
-    {lists:reverse(L), []}.
-
+get_name([], Acc) ->
+    {list_to_atom(lists:reverse(Acc)),[]}.
 	    
 isalnum(H) when $A =< H , H =< $Z ->
     true;
@@ -221,67 +208,54 @@ isdigit(H) when $0 =< H , H =< $9 ->
 isdigit(_) ->
     false.
 
-white_space(9) -> true;
-white_space(10) -> true;
-white_space(13) -> true;
-white_space(32) -> true;
-white_space(_) -> false.
-
-
-get_number([H|T], L) ->
+get_number([H|T]=T0, L) ->
     case isdigit(H) of
 	true ->
 	    get_number(T, [H|L]);
 	false ->
-	    {lists:reverse(L), [H|T]}
+	    {lists:reverse(L), T0}
     end;
 get_number([], L) ->
     {lists:reverse(L), []}.
 
-skip_comment([]) ->
-    [];
-skip_comment([$-,$-|T]) ->
-    T;
-skip_comment([_|T]) ->
-    skip_comment(T).
-
+skip_comment([]) -> [];
+skip_comment("--"++T) -> T;
+skip_comment([_|T]) -> skip_comment(T).
 
-skip_multiline_comment(Stream,[],Lno,Level) ->
-    case io:get_line(Stream,'') of
+skip_multiline_comment(Stream, [], Lno, Level) ->
+    case io:get_line(Stream, '') of
 	eof ->
-	    io:format("Tokeniser error on line: ~w~n"
-		      "premature end of multiline comment~n",[Lno]),
-	    exit(0);
+	    throw({error,eof_in_comment});
 	Line ->
-	    skip_multiline_comment(Stream,Line,Lno+1,Level)
+	    skip_multiline_comment(Stream, Line, Lno+1, Level)
     end;
-skip_multiline_comment(_Stream,[$*,$/|T],Lno,0) ->
+skip_multiline_comment(_Stream, "*/"++T, Lno, 0) ->
     {Lno,T};
-skip_multiline_comment(Stream,[$*,$/|T],Lno,Level) ->
-    skip_multiline_comment(Stream,T,Lno,Level - 1);
-skip_multiline_comment(Stream,[$/,$*|T],Lno,Level) ->
-    skip_multiline_comment(Stream,T,Lno,Level + 1);
-skip_multiline_comment(Stream,[_|T],Lno,Level) ->
-    skip_multiline_comment(Stream,T,Lno,Level).
-
-collect_quoted([$',$B|T],Lno, L) ->
+skip_multiline_comment(Stream, "*/"++T, Lno, Level) ->
+    skip_multiline_comment(Stream, T, Lno, Level - 1);
+skip_multiline_comment(Stream, "/*"++T, Lno, Level) ->
+    skip_multiline_comment(Stream, T, Lno, Level + 1);
+skip_multiline_comment(Stream, [_|T], Lno, Level) ->
+    skip_multiline_comment(Stream, T, Lno, Level).
+
+collect_quoted("'B"++T, Lno, L) ->
     case check_bin(L) of
         true ->
-            {{bstring,Lno, lists:reverse(L)}, T};
+            {{bstring,Lno,lists:reverse(L)}, T};
         false ->
-            throw({'ERR',{invalid_binary_number, lists:reverse(L)}})
+            throw({error,{invalid_binary_number,lists:reverse(L)}})
     end;
-collect_quoted([$',$H|T],Lno, L) ->
+collect_quoted("'H"++T, Lno, L) ->
     case check_hex(L) of
         true ->
-            {{hstring,Lno, lists:reverse(L)}, T};
+            {{hstring,Lno,lists:reverse(L)}, T};
         false ->
-            throw({'ERR',{invalid_binary_number, lists:reverse(L)}})
+            throw({error,{invalid_hex_number,lists:reverse(L)}})
     end;
 collect_quoted([H|T], Lno, L) ->
     collect_quoted(T, Lno,[H|L]);
 collect_quoted([], _, _) ->        % This should be allowed FIX later
-    throw({'ERR',{eol_in_token}}).
+    throw({error,eol_in_token}).
 
 check_bin([$0|T]) ->
     check_bin(T);
@@ -309,7 +283,6 @@ check_hex(_) ->
 %% returns rstrtype if A is a reserved word in the group 
 %% 	RestrictedCharacterStringType
 reserved_word('ABSENT') -> true;
-%reserved_word('ABSTRACT-SYNTAX') -> true; % impl as predef item
 reserved_word('ALL') -> true;
 reserved_word('ANY') -> true;
 reserved_word('APPLICATION') -> true;
@@ -352,7 +325,6 @@ reserved_word('INCLUDES') -> true;
 reserved_word('INSTANCE') -> true;
 reserved_word('INTEGER') -> true;
 reserved_word('INTERSECTION') -> true;
-reserved_word('ISO646String') -> rstrtype;
 reserved_word('MAX') -> true;
 reserved_word('MIN') -> true;
 reserved_word('MINUS-INFINITY') -> true;
@@ -380,7 +352,6 @@ reserved_word('T61String') -> rstrtype;
 reserved_word('TAGS') -> true;
 reserved_word('TeletexString') -> rstrtype;
 reserved_word('TRUE') -> true;
-%% reserved_word('TYPE-IDENTIFIER') -> true; % impl as predef item
 reserved_word('UNION') -> true;
 reserved_word('UNIQUE') -> true;
 reserved_word('UNIVERSAL') -> true;
diff --git a/lib/asn1/src/asn1ct_value.erl b/lib/asn1/src/asn1ct_value.erl
index ecdfa3f645..57cd3f8af6 100644
--- a/lib/asn1/src/asn1ct_value.erl
+++ b/lib/asn1/src/asn1ct_value.erl
@@ -1,23 +1,25 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1997-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %% 
 %% %CopyrightEnd%
 %%
 %%
 -module(asn1ct_value).
+-compile([{nowarn_deprecated_function,{asn1rt,utf8_list_to_binary,1}}]).
 
 %%  Generate Erlang values for ASN.1 types.
 %%  The value is randomized within it's constraints
@@ -32,11 +34,11 @@
 
 
 from_type(M,Typename) ->
-    case asn1_db:dbget(M,Typename) of
-	undefined -> 
+    case asn1_db:dbload(M) of
+	error ->
 	    {error,{not_found,{M,Typename}}};
-	Tdef when is_record(Tdef,typedef) ->
-	    Type = Tdef#typedef.typespec,
+	ok ->
+	    #typedef{typespec=Type} = asn1_db:dbget(M, Typename),
 	    from_type(M,[Typename],Type);
     Vdef when is_record(Vdef,valuedef) ->
         from_value(Vdef);
@@ -167,17 +169,16 @@ from_type_prim(M, D) ->
     case D#type.def of
 	'INTEGER' ->
 	    i_random(C);
-	{'INTEGER',NamedNumberList} ->
-	    NN = [X||{X,_} <- NamedNumberList],
-	    case NN of 
+	{'INTEGER',[_|_]=NNL} ->
+	    case C of
 		[] ->
-		    i_random(C);
+		    {N,_} = lists:nth(random(length(NNL)), NNL),
+		    N;
 		_ ->
-		    case C of
-			[] ->
-			    lists:nth(random(length(NN)),NN);
-			_ ->
-			    lists:nth((fun(0)->1;(X)->X end(i_random(C))),NN)
+		    V = i_random(C),
+		    case lists:keyfind(V, 2, NNL) of
+			false -> V;
+			{N,V} -> N
 		    end
 	    end;
 	Enum when is_tuple(Enum),element(1,Enum)=='ENUMERATED' ->
@@ -261,7 +262,11 @@ from_type_prim(M, D) ->
 	'BOOLEAN' ->
 	    true;
 	'OCTET STRING' ->
-	    adjust_list(size_random(C),c_string(C,"OCTET STRING"));
+	    S0 = adjust_list(size_random(C), c_string(C, "OCTET STRING")),
+	    case M:legacy_erlang_types() of
+		false -> list_to_binary(S0);
+		true -> S0
+	    end;
 	'NumericString' ->
 	    adjust_list(size_random(C),c_string(C,"0123456789"));
 	'TeletexString' ->
@@ -348,9 +353,7 @@ random_unnamed_bit_string(M, C) ->
 %%     end.
 
 random(Upper) ->
-    {A1,A2,A3} = erlang:now(),
-    random:seed(A1,A2,A3),
-    random:uniform(Upper).
+    rand:uniform(Upper).
 
 size_random(C) ->
     case get_constraint(C,'SizeConstraint') of
diff --git a/lib/asn1/src/asn1rt.erl b/lib/asn1/src/asn1rt.erl
index d18f81346a..3e09ce2252 100644
--- a/lib/asn1/src/asn1rt.erl
+++ b/lib/asn1/src/asn1rt.erl
@@ -1,31 +1,31 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1997-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2016. All Rights Reserved.
 %% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %% 
 %% %CopyrightEnd%
 %%
 %%
 -module(asn1rt).
+-deprecated(module).
 
 %% Runtime functions for ASN.1 (i.e encode, decode)
 
 -export([encode/2,encode/3,decode/3,load_driver/0,unload_driver/0,info/1]).
 
 -export([utf8_binary_to_list/1,utf8_list_to_binary/1]).
-    
--deprecated([load_driver/0,unload_driver/0]).
 
 encode(Module,{Type,Term}) ->
     encode(Module,Type,Term).
diff --git a/lib/asn1/src/asn1rt_nif.erl b/lib/asn1/src/asn1rt_nif.erl
index c1879e3dcf..ff464885f6 100644
--- a/lib/asn1/src/asn1rt_nif.erl
+++ b/lib/asn1/src/asn1rt_nif.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2002-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -30,7 +31,7 @@
 -define(ASN1_NIF_VSN,1).
 
 load_nif() ->
-    LibBaseName = "asn1_erl_nif",
+    LibBaseName = "asn1rt_nif",
     PrivDir = code:priv_dir(asn1),
     LibName = case erlang:system_info(build_type) of
 		  opt ->
diff --git a/lib/asn1/src/asn1rtt_ber.erl b/lib/asn1/src/asn1rtt_ber.erl
index b5429fe324..fdb9b9061f 100644
--- a/lib/asn1/src/asn1rtt_ber.erl
+++ b/lib/asn1/src/asn1rtt_ber.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -22,27 +23,28 @@
 %% encoding / decoding of BER
 
 -export([ber_decode_nif/1,ber_decode_erlang/1,match_tags/2,ber_encode/1]).
--export([encode_tags/2,
-	 encode_tags/3,
+-export([encode_tags/3,
 	 skip_ExtensionAdditions/2]).
 -export([encode_boolean/2,decode_boolean/2,
 	 encode_integer/2,encode_integer/3,
-	 decode_integer/2,decode_integer/3,
-	 decode_named_integer/3,decode_named_integer/4,
-	 encode_enumerated/2,decode_enumerated/3,
+	 decode_integer/2,
+	 number2name/2,
+	 encode_unnamed_bit_string/2,encode_unnamed_bit_string/3,
+	 encode_named_bit_string/3,encode_named_bit_string/4,
 	 encode_bit_string/4,
 	 decode_named_bit_string/3,
-	 decode_compact_bit_string/3,
-	 decode_legacy_bit_string/3,
-	 decode_native_bit_string/3,
+	 decode_compact_bit_string/2,compact_bit_string_size/1,
+	 decode_native_bit_string/2,
+	 native_to_legacy_bit_string/1,
 	 encode_null/2,decode_null/2,
 	 encode_relative_oid/2,decode_relative_oid/2,
 	 encode_object_identifier/2,decode_object_identifier/2,
 	 encode_restricted_string/2,
-	 decode_restricted_string/2,decode_restricted_string/3,
-	 encode_universal_string/2,decode_universal_string/3,
+	 decode_octet_string/2,
+	 decode_restricted_string/2,
+	 encode_universal_string/2,decode_universal_string/2,
 	 encode_UTF8_string/2,decode_UTF8_string/2,
-	 encode_BMP_string/2,decode_BMP_string/3]).
+	 encode_BMP_string/2,decode_BMP_string/2]).
 
 -export([encode_open_type/2,decode_open_type/2,
 	 decode_open_type_as_binary/2]).
@@ -589,8 +591,6 @@ encode_tags(TagIn, {BytesSoFar,LenSoFar}) ->
 
 encode_open_type(Val, T) when is_list(Val) ->
     encode_open_type(list_to_binary(Val), T);
-encode_open_type(Val, []) ->
-    {Val,byte_size(Val)};
 encode_open_type(Val, Tag) ->
     encode_tags(Tag, Val, byte_size(Val)).
 
@@ -695,41 +695,14 @@ encode_integer_neg(N, Acc) ->
 
 %%===============================================================================
 %% decode integer
-%%    (Buffer, Range, HasTag, TotalLen) -> {Integer, Remain, RemovedBytes}
-%%    (Buffer, Range, NamedNumberList, HasTag, TotalLen) -> {Integer, Remain, RemovedBytes}
 %%===============================================================================
 
-decode_named_integer(Tlv, NamedNumberList, TagIn) ->
-    V = match_tags(Tlv, TagIn),
-    Int = decode_integer(V),
-    number2name(Int, NamedNumberList).
-
-decode_named_integer(Tlv, Range, NamedNumberList, TagIn) ->
-    V = match_tags(Tlv, TagIn),
-    Int = range_check_integer(decode_integer(V), Range),
-    number2name(Int, NamedNumberList).
-
 decode_integer(Tlv, TagIn) ->
-    V = match_tags(Tlv, TagIn),
-    decode_integer(V).
-
-decode_integer(Tlv, Range, TagIn) ->
-    V = match_tags(Tlv, TagIn),
-    Int = decode_integer(V),
-    range_check_integer(Int, Range).
-
-decode_integer(Bin) ->
+    Bin = match_tags(Tlv, TagIn),
     Len = byte_size(Bin),
     <<Int:Len/signed-unit:8>> = Bin,
     Int.
 
-range_check_integer(Int, {Lb,Ub}) when Lb =< Int, Int =< Ub ->
-    Int;
-range_check_integer(Int, Range) ->
-    exit({error,{asn1,{integer_range,Range,Int}}}).
-
-number2name(Int, []) ->
-    Int;
 number2name(Int, NamedNumberList) ->
     case lists:keyfind(Int, 2, NamedNumberList) of
 	{NamedVal,_} ->
@@ -738,49 +711,60 @@ number2name(Int, NamedNumberList) ->
 	    Int
     end.
 
-
 %%============================================================================
-%% Enumerated value, ITU_T X.690 Chapter 8.4
-
-%% encode enumerated value
+%% Bitstring value, ITU_T X.690 Chapter 8.6
+%%
+%% encode bitstring value
 %%============================================================================
-encode_enumerated(Val, TagIn) when is_integer(Val) ->
-    encode_tags(TagIn, encode_integer(Val)).
 
-%%============================================================================
-%% decode enumerated value
-%%   (Buffer, Range, NamedNumberList, HasTag, TotalLen) ->  Value
-%%===========================================================================
-decode_enumerated(Tlv, NamedNumberList, Tags) ->
-    Buffer = match_tags(Tlv, Tags),
-    decode_enumerated_notag(Buffer, NamedNumberList, Tags).
-
-decode_enumerated_notag(Buffer, {NamedNumberList,ExtList}, _Tags) ->
-    IVal = decode_integer(Buffer),
-    case decode_enumerated1(IVal, NamedNumberList) of
-	{asn1_enum,IVal} ->
-	    decode_enumerated1(IVal,ExtList);
-	EVal ->
-	    EVal
-    end;
-decode_enumerated_notag(Buffer, NNList, _Tags) ->
-    IVal = decode_integer(Buffer),
-    case decode_enumerated1(IVal, NNList) of
-	{asn1_enum,_} ->
-	    exit({error,{asn1, {illegal_enumerated, IVal}}});
-	EVal ->
-	    EVal
-    end.
+encode_unnamed_bit_string(Bits, TagIn) ->
+    Unused = (8 - (bit_size(Bits) band 7)) band 7,
+    Bin = <<Unused,Bits/bitstring,0:Unused>>,
+    encode_tags(TagIn, Bin, byte_size(Bin)).
 
-decode_enumerated1(Val, NamedNumberList) ->
-    %% it must be a named integer
-    case lists:keyfind(Val, 2, NamedNumberList) of
-	{NamedVal, _} ->
-	    NamedVal;
-	_ ->
-	    {asn1_enum,Val}
+encode_unnamed_bit_string(MaxBits, Bits, TagIn) ->
+    NumBits = bit_size(Bits),
+    Unused = (8 - (NumBits band 7)) band 7,
+    Bin = <<Unused,Bits/bitstring,0:Unused>>,
+    if
+	NumBits > MaxBits ->
+	    exit({error,{asn1,
+			 {bitstring_length,
+			  {{was,NumBits},{maximum,MaxBits}}}}});
+	true ->
+	    encode_tags(TagIn, Bin, byte_size(Bin))
     end.
 
+encode_named_bit_string([H|_]=Bits, NamedBitList, TagIn) when is_atom(H) ->
+    do_encode_named_bit_string(Bits, NamedBitList, TagIn);
+encode_named_bit_string([{bit,_}|_]=Bits, NamedBitList, TagIn) ->
+    do_encode_named_bit_string(Bits, NamedBitList, TagIn);
+encode_named_bit_string([], _NamedBitList, TagIn) ->
+    encode_unnamed_bit_string(<<>>, TagIn);
+encode_named_bit_string(Bits, _NamedBitList, TagIn) when is_bitstring(Bits) ->
+    encode_unnamed_bit_string(Bits, TagIn).
+
+encode_named_bit_string(C, [H|_]=Bits, NamedBitList, TagIn) when is_atom(H) ->
+    do_encode_named_bit_string(C, Bits, NamedBitList, TagIn);
+encode_named_bit_string(C, [{bit,_}|_]=Bits, NamedBitList, TagIn) ->
+    do_encode_named_bit_string(C, Bits, NamedBitList, TagIn);
+encode_named_bit_string(C, [], _NamedBitList, TagIn) ->
+    encode_unnamed_bit_string(C, <<>>, TagIn);
+encode_named_bit_string(C, Bits, _NamedBitList, TagIn) when is_bitstring(Bits) ->
+    encode_unnamed_bit_string(C, Bits, TagIn).
+
+do_encode_named_bit_string([FirstVal | RestVal], NamedBitList, TagIn) ->
+    ToSetPos = get_all_bitposes([FirstVal | RestVal], NamedBitList, []),
+    Size = lists:max(ToSetPos) + 1,
+    BitList = make_and_set_list(Size, ToSetPos, 0),
+    {Len,Unused,OctetList} = encode_bitstring(BitList),
+    encode_tags(TagIn, [Unused|OctetList],Len+1).
+
+do_encode_named_bit_string(Size, [FirstVal | RestVal], NamedBitList, TagIn) ->
+    ToSetPos = get_all_bitposes([FirstVal | RestVal], NamedBitList, []),
+    BitList = make_and_set_list(Size, ToSetPos, 0),
+    {Len, Unused, OctetList} = encode_bitstring(BitList),
+    encode_tags(TagIn, [Unused|OctetList], Len+1).
 
 %%============================================================================
 %% Bitstring value, ITU_T X.690 Chapter 8.6
@@ -881,15 +865,14 @@ remove_unused_then_dotag(TagIn,Unused,BinBits) ->
 
 encode_bit_string_named(C, [FirstVal | RestVal], NamedBitList, TagIn) ->
     ToSetPos = get_all_bitposes([FirstVal | RestVal], NamedBitList, []),
-    Size =
-	case C of
-	    [] ->
-		lists:max(ToSetPos)+1;
-	    {_Min,Max} ->
-		Max;
-	    TSize ->
-		TSize
-	end,
+    Size = case C of
+	       [] ->
+		   lists:max(ToSetPos) + 1;
+	       {_Min,Max} ->
+		   Max;
+	       TSize ->
+		   TSize
+	   end,
     BitList = make_and_set_list(Size, ToSetPos, 0),
     {Len, Unused, OctetList} = encode_bitstring(BitList),
     encode_tags(TagIn, [Unused|OctetList],Len+1).
@@ -1047,33 +1030,23 @@ unused_bitlist([Bit | Rest], Trail, Ack) ->
 %% decode bitstring value
 %%============================================================================
 
-decode_compact_bit_string(Buffer, Range, Tags) ->
+decode_compact_bit_string(Buffer, Tags) ->
     case match_and_collect(Buffer, Tags) of
-	<<0>> ->
-	    check_restricted_string({0,<<>>}, 0, Range);
-	<<Unused,Bits/binary>> ->
-	    Val = {Unused,Bits},
-	    Len = bit_size(Bits) - Unused,
-	    check_restricted_string(Val, Len, Range)
+	<<0>> -> {0,<<>>};
+	<<Unused,Bits/binary>> -> {Unused,Bits}
     end.
 
-decode_legacy_bit_string(Buffer, Range, Tags) ->
-    Val = case match_and_collect(Buffer, Tags) of
-	      <<0>> ->
-		  [];
-	      <<Unused,Bits/binary>> ->
-		  decode_bitstring2(byte_size(Bits), Unused, Bits)
-	  end,
-    check_restricted_string(Val, length(Val), Range).
+compact_bit_string_size({Unused,Bits}) ->
+    bit_size(Bits) - Unused.
 
-decode_native_bit_string(Buffer, Range, Tags) ->
+decode_native_bit_string(Buffer, Tags) ->
     case match_and_collect(Buffer, Tags) of
 	<<0>> ->
-	    check_restricted_string(<<>>, 0, Range);
+	    <<>>;
 	<<Unused,Bits/binary>> ->
 	    Size = bit_size(Bits) - Unused,
 	    <<Val:Size/bitstring,_:Unused/bitstring>> = Bits,
-	    check_restricted_string(Val, Size, Range)
+	    Val
     end.
 
 decode_named_bit_string(Buffer, NamedNumberList, Tags) ->
@@ -1096,6 +1069,9 @@ decode_bitstring2(Len, Unused,
     [B7,B6,B5,B4,B3,B2,B1,B0|
      decode_bitstring2(Len - 1, Unused, Buffer)].
 
+native_to_legacy_bit_string(Bits) ->
+    [B || <<B:1>> <= Bits].
+
 %%----------------------------------------
 %% Decode the bitlist to names
 %%----------------------------------------
@@ -1252,25 +1228,19 @@ encode_restricted_string(OctetList, TagIn) when is_list(OctetList) ->
     encode_tags(TagIn, OctetList, length(OctetList)).
 
 %%============================================================================
-%% decode Numeric Printable Teletex Videotex Visible IA5 Graphic General strings
+%% decode OCTET STRING to binary
 %%============================================================================
 
-decode_restricted_string(Tlv, TagsIn) ->
+decode_octet_string(Tlv, TagsIn) ->
     Bin = match_and_collect(Tlv, TagsIn),
-    binary_to_list(Bin).
+    binary:copy(Bin).
 
-decode_restricted_string(Tlv, Range, TagsIn) ->
-    Bin = match_and_collect(Tlv, TagsIn),
-    check_restricted_string(binary_to_list(Bin), byte_size(Bin), Range).
+%%============================================================================
+%% decode Numeric Printable Teletex Videotex Visible IA5 Graphic General strings
+%%============================================================================
 
-check_restricted_string(Val, _Len, []) ->
-    Val;
-check_restricted_string(Val, Len, {Lb,Ub}) when Lb =< Len, Len =< Ub ->
-    Val;
-check_restricted_string(Val, Len, Len) ->
-    Val;
-check_restricted_string(Val, _Len, Range) ->
-    exit({error,{asn1,{length,Range,Val}}}).
+decode_restricted_string(Tlv, TagsIn) ->
+    match_and_collect(Tlv, TagsIn).
 
 %%============================================================================
 %% encode Universal string
@@ -1296,10 +1266,9 @@ mk_uni_list([H|T],List) ->
 %%                           {String, Remain, RemovedBytes}
 %%===========================================================================
 
-decode_universal_string(Buffer, Range, Tags) ->
+decode_universal_string(Buffer, Tags) ->
     Bin = match_and_collect(Buffer, Tags),
-    Val = mk_universal_string(binary_to_list(Bin)),
-    check_restricted_string(Val, length(Val), Range).
+    mk_universal_string(binary_to_list(Bin)).
 
 mk_universal_string(In) ->
     mk_universal_string(In, []).
@@ -1359,10 +1328,9 @@ mk_BMP_list([H|T], List) ->
 %%    (Buffer, Range, StringType, HasTag, TotalLen) ->
 %%                               {String, Remain, RemovedBytes}
 %%============================================================================
-decode_BMP_string(Buffer, Range, Tags) ->
+decode_BMP_string(Buffer, Tags) ->
     Bin = match_and_collect(Buffer, Tags),
-    Val = mk_BMP_string(binary_to_list(Bin)),
-    check_restricted_string(Val, length(Val), Range).
+    mk_BMP_string(binary_to_list(Bin)).
 
 mk_BMP_string(In) ->
     mk_BMP_string(In,[]).
diff --git a/lib/asn1/src/asn1rtt_check.erl b/lib/asn1/src/asn1rtt_check.erl
index e78b65a8fb..e81842fd20 100644
--- a/lib/asn1/src/asn1rtt_check.erl
+++ b/lib/asn1/src/asn1rtt_check.erl
@@ -1,227 +1,168 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
 -module(asn1rtt_check).
 
--export([check_bool/2,
+-export([check_fail/1,
 	 check_int/3,
-	 check_bitstring/3,
+	 check_legacy_bitstring/2,
+	 check_legacy_named_bitstring/3,
+	 check_legacy_named_bitstring/4,
+	 check_named_bitstring/3,
+	 check_named_bitstring/4,
+	 check_literal_sof/2,
 	 check_octetstring/2,
-	 check_null/2,
 	 check_objectidentifier/2,
 	 check_objectdescriptor/2,
 	 check_real/2,
-	 check_enum/3,
 	 check_restrictedstring/2]).
 
-check_bool(_Bool, asn1_DEFAULT) ->
-    true;
-check_bool(Bool, Bool) when is_boolean(Bool) ->
-    true;
-check_bool(_Bool1, Bool2) ->
-    throw({error,Bool2}).
+check_fail(_) ->
+    throw(false).
 
-check_int(_, asn1_DEFAULT, _) ->
-    true;
 check_int(Value, Value, _) when is_integer(Value) ->
     true;
-check_int(DefValue, Value, NNL) when is_atom(Value) ->
+check_int(Value, DefValue, NNL) when is_atom(Value) ->
     case lists:keyfind(Value, 1, NNL) of
 	{_,DefValue} ->
 	    true;
 	_ ->
-	    throw({error,DefValue})
-    end;
-check_int(DefaultValue, _Value, _) ->
-    throw({error,DefaultValue}).
-
-%% Two equal lists or integers
-check_bitstring(_, asn1_DEFAULT, _) ->
-    true;
-check_bitstring(V, V, _) ->
-    true;
-%% Default value as a list of 1 and 0 and user value as an integer
-check_bitstring(L=[H|T], Int, _) when is_integer(Int), is_integer(H) ->
-    case bit_list_to_int(L, length(T)) of
-	Int -> true;
-	_ -> throw({error,L,Int})
+	    throw(false)
     end;
-%% Default value as an integer, val as list
-check_bitstring(Int, Val, NBL) when is_integer(Int), is_list(Val) ->
-    BL = int_to_bit_list(Int, [], length(Val)),
-    check_bitstring(BL, Val, NBL);
-%% Default value and user value as lists of ones and zeros
-check_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL=[_H|_T]) when is_integer(H1), is_integer(H2) ->
-    L2new = remove_trailing_zeros(L2),
-    check_bitstring(L1, L2new, NBL);
-%% Default value as a list of 1 and 0 and user value as a list of atoms
-check_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL) when is_integer(H1), is_atom(H2) ->
-    L3 = bit_list_to_nbl(L1, NBL, 0, []),
-    check_bitstring(L3, L2, NBL);
-%% Both default value and user value as a list of atoms
-check_bitstring(L1=[H1|T1], L2=[H2|_T2], _)
-  when is_atom(H1), is_atom(H2), length(L1) =:= length(L2) ->
-    case lists:member(H1, L2) of
-	true ->
-	    check_bitstring1(T1, L2);
-	false -> throw({error,L2})
+check_int(_, _, _) ->
+    throw(false).
+
+check_legacy_bitstring(Value, Default) ->
+    check_bitstring(Default, Value).
+
+%% check_bitstring(Default, UserBitstring) -> true|false
+%%  Default = bitstring()
+%%  UserBitstring = integeger() | list(0|1) | {Unused,binary()} | bitstring()
+check_bitstring(DefVal, {Unused,Binary}) ->
+    %% User value in compact format.
+    Sz = bit_size(Binary) - Unused,
+    <<Val:Sz/bitstring,_:Unused>> = Binary,
+    check_bitstring(DefVal, Val);
+check_bitstring(DefVal, Val) when is_bitstring(Val) ->
+    case Val =:= DefVal of
+	false -> throw(false);
+	true -> true
     end;
-%% Default value as a list of atoms and user value as a list of 1 and 0
-check_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL) when is_atom(H1), is_integer(H2) ->
-    L3 = bit_list_to_nbl(L2, NBL, 0, []),
-    check_bitstring(L1, L3, NBL);
-%% User value in compact format
-check_bitstring(DefVal,CBS={_,_}, NBL) ->
-    NewVal = cbs_to_bit_list(CBS),
-    check_bitstring(DefVal, NewVal, NBL);
-check_bitstring(DV, V, _) ->
-    throw({error,DV,V}).
-
-
-bit_list_to_int([0|Bs], ShL)->
-    bit_list_to_int(Bs, ShL-1) + 0;
-bit_list_to_int([1|Bs], ShL) ->
-    bit_list_to_int(Bs, ShL-1) + (1 bsl ShL);
-bit_list_to_int([], _) ->
-    0.
-
-int_to_bit_list(0, Acc, 0) ->
-    Acc;
-int_to_bit_list(Int, Acc, Len) ->
-    int_to_bit_list(Int bsr 1, [Int band 1|Acc], Len - 1).
-
-bit_list_to_nbl([0|T], NBL, Pos, Acc) ->
-    bit_list_to_nbl(T, NBL, Pos+1, Acc);
-bit_list_to_nbl([1|T], NBL, Pos, Acc) ->
-    case lists:keyfind(Pos, 2, NBL) of
-	{N,_} ->
-	    bit_list_to_nbl(T, NBL, Pos+1, [N|Acc]);
+check_bitstring(Def, Val) when is_list(Val) ->
+    check_bitstring_list(Def, Val);
+check_bitstring(Def, Val) when is_integer(Val) ->
+    check_bitstring_integer(Def, Val).
+
+check_bitstring_list(<<H:1,T1/bitstring>>, [H|T2]) ->
+    check_bitstring_list(T1, T2);
+check_bitstring_list(<<>>, []) ->
+    true;
+check_bitstring_list(_, _) ->
+    throw(false).
+
+check_bitstring_integer(<<H:1,T1/bitstring>>, Int) when H =:= Int band 1 ->
+    check_bitstring_integer(T1, Int bsr 1);
+check_bitstring_integer(<<>>, 0) ->
+    true;
+check_bitstring_integer(_, _) ->
+    throw(false).
+
+check_legacy_named_bitstring([Int|_]=Val, Bs, BsSize) when is_integer(Int) ->
+    check_named_bitstring(<< <<B:1>> || B <- Val >>, Bs, BsSize);
+check_legacy_named_bitstring({Unused,Val0}, Bs, BsSize) ->
+    Sz = bit_size(Val0) - Unused,
+    <<Val:Sz/bits,_/bits>> = Val0,
+    check_named_bitstring(Val, Bs, BsSize);
+check_legacy_named_bitstring(Val, Bs, BsSize) when is_integer(Val) ->
+    L = legacy_int_to_bitlist(Val),
+    check_named_bitstring(<< <<B:1>> || B <- L >>, Bs, BsSize);
+check_legacy_named_bitstring(Val, Bs, BsSize) ->
+    check_named_bitstring(Val, Bs, BsSize).
+
+check_legacy_named_bitstring([Int|_]=Val, Names, Bs, BsSize) when is_integer(Int) ->
+    check_named_bitstring(<< <<B:1>> || B <- Val >>, Names, Bs, BsSize);
+check_legacy_named_bitstring({Unused,Val0}, Names, Bs, BsSize) ->
+    Sz = bit_size(Val0) - Unused,
+    <<Val:Sz/bits,_/bits>> = Val0,
+    check_named_bitstring(Val, Names, Bs, BsSize);
+check_legacy_named_bitstring(Val, Names, Bs, BsSize) when is_integer(Val) ->
+    L = legacy_int_to_bitlist(Val),
+    check_named_bitstring(<< <<B:1>> || B <- L >>, Names, Bs, BsSize);
+check_legacy_named_bitstring(Val, Names, Bs, BsSize) ->
+    check_named_bitstring(Val, Names, Bs, BsSize).
+
+legacy_int_to_bitlist(0) ->
+    [];
+legacy_int_to_bitlist(Int) ->
+    [Int band 1|legacy_int_to_bitlist(Int bsr 1)].
+
+check_named_bitstring(Bs, Bs, _) ->
+    true;
+check_named_bitstring(Val, Bs, BsSize) ->
+    Rest = bit_size(Val) - BsSize,
+    case Val of
+	<<Bs:BsSize/bits,0:Rest>> ->
+	    true;
 	_ ->
-	    throw({error,{no,named,element,at,pos,Pos}})
-    end;
-bit_list_to_nbl([], _, _, Acc) ->
-    Acc.
-
-remove_trailing_zeros(L2) ->
-    remove_trailing_zeros1(lists:reverse(L2)).
-remove_trailing_zeros1(L) ->
-    lists:reverse(lists:dropwhile(fun(0)->true;
-				     (_) ->false
-				  end,
-				  L)).
-
-check_bitstring1([H|T], NBL) ->
-    case lists:member(H, NBL) of
-	true -> check_bitstring1(T, NBL);
-	V -> throw({error,V})
-    end;
-check_bitstring1([], _) ->
-    true.
-
-cbs_to_bit_list({Unused, <<B7:1,B6:1,B5:1,B4:1,B3:1,B2:1,B1:1,B0:1,Rest/binary>>}) when byte_size(Rest) >= 1 ->
-    [B7,B6,B5,B4,B3,B2,B1,B0|cbs_to_bit_list({Unused,Rest})];
-cbs_to_bit_list({0,<<B7:1,B6:1,B5:1,B4:1,B3:1,B2:1,B1:1,B0:1>>}) ->
-    [B7,B6,B5,B4,B3,B2,B1,B0];
-cbs_to_bit_list({Unused,Bin}) when byte_size(Bin) =:= 1 ->
-    Used = 8-Unused,
-    <<Int:Used,_:Unused>> = Bin,
-    int_to_bit_list(Int, [], Used).
-
+	    throw(false)
+    end.
 
-check_octetstring(_, asn1_DEFAULT) ->
-    true;
-check_octetstring(L, L) ->
-    true;
-check_octetstring(L, Int) when is_list(L), is_integer(Int) ->
-    case integer_to_octetlist(Int) of
-	L -> true;
-	V -> throw({error,V})
+check_named_bitstring([_|_]=Val, Names, _, _) ->
+    case lists:sort(Val) of
+	Names -> true;
+	_ -> throw(false)
     end;
-check_octetstring(_, V) ->
-    throw({error,V}).
-
-integer_to_octetlist(Int) ->
-    integer_to_octetlist(Int, []).
-integer_to_octetlist(0, Acc) ->
-    Acc;
-integer_to_octetlist(Int, Acc) ->
-    integer_to_octetlist(Int bsr 8, [(Int band 255)|Acc]).
-
-check_null(_, asn1_DEFAULT) ->
-    true;
-check_null('NULL', 'NULL') ->
+check_named_bitstring(Bs, _, Bs, _) ->
     true;
-check_null(_, V) ->
-    throw({error,V}).
+check_named_bitstring(Val, _, Bs, BsSize) ->
+    Rest = bit_size(Val) - BsSize,
+    case Val of
+	<<Bs:BsSize/bits,0:Rest>> ->
+	    true;
+	_ ->
+	    throw(false)
+    end.
 
-check_objectidentifier(_, asn1_DEFAULT) ->
-    true;
-check_objectidentifier(OI, OI) ->
+check_octetstring(V, V) ->
     true;
-check_objectidentifier(DOI, OI) when is_tuple(DOI), is_tuple(OI) ->
-    check_objectidentifier1(tuple_to_list(DOI), tuple_to_list(OI));
-check_objectidentifier(_, OI) ->
-    throw({error,OI}).
-
-check_objectidentifier1([V|Rest1], [V|Rest2]) ->
-    check_objectidentifier1(Rest1, Rest2, V);
-check_objectidentifier1([V1|Rest1], [V2|Rest2]) ->
-    case reserved_objectid(V2, []) of
-	V1 ->
-	    check_objectidentifier1(Rest1, Rest2, [V1]);
-	V ->
-	    throw({error,V})
-    end.
-check_objectidentifier1([V|Rest1], [V|Rest2], Above) ->
-    check_objectidentifier1(Rest1, Rest2, [V|Above]);
-check_objectidentifier1([V1|Rest1], [V2|Rest2], Above) ->
-    case reserved_objectid(V2, Above) of
-	V1 ->
-	    check_objectidentifier1(Rest1, Rest2, [V1|Above]);
-	V ->
-	    throw({error,V})
+check_octetstring(V, Def) when is_list(V) ->
+    case list_to_binary(V) of
+	Def -> true;
+	_ -> throw(false)
+    end;
+check_octetstring(_, _) ->
+    throw(false).
+
+check_objectidentifier(Value, {Prefix,Tail}) when is_tuple(Value) ->
+    check_oid(tuple_to_list(Value), Prefix, Tail);
+check_objectidentifier(_, _) ->
+    throw(false).
+
+check_oid([H|T], [K|Ks], Tail) ->
+    case lists:member(H, K) of
+	false -> throw(false);
+	true -> check_oid(T, Ks, Tail)
     end;
-check_objectidentifier1([], [], _) ->
+check_oid(Tail, [], Tail) ->
     true;
-check_objectidentifier1(_, V, _) ->
-    throw({error,object,identifier,V}).
-
-%% ITU-T Rec. X.680 Annex B - D
-reserved_objectid('itu-t', []) -> 0;
-reserved_objectid('ccitt', []) -> 0;
-%% arcs below "itu-t"
-reserved_objectid('recommendation', [0]) -> 0;
-reserved_objectid('question', [0]) -> 1;
-reserved_objectid('administration', [0]) -> 2;
-reserved_objectid('network-operator', [0]) -> 3;
-reserved_objectid('identified-organization', [0]) -> 4;
-
-reserved_objectid(iso, []) -> 1;
-%% arcs below "iso", note that number 1 is not used
-reserved_objectid('standard', [1]) -> 0;
-reserved_objectid('member-body', [1]) -> 2;
-reserved_objectid('identified-organization', [1]) -> 3;
-
-reserved_objectid('joint-iso-itu-t', []) -> 2;
-reserved_objectid('joint-iso-ccitt', []) -> 2;
-
-reserved_objectid(_, _) -> false.
-
+check_oid(_, _, _) ->
+    throw(false).
 
 check_objectdescriptor(_, asn1_DEFAULT) ->
     true;
@@ -237,21 +178,6 @@ check_real(R, R) ->
 check_real(_, _) ->
     throw({error,{not_implemented_yet,check_real}}).
 
-check_enum(_, asn1_DEFAULT, _) ->
-    true;
-check_enum(Val, Val, _) ->
-    true;
-check_enum(Int, Atom, Enumerations) when is_integer(Int), is_atom(Atom) ->
-    case lists:keyfind(Atom, 1, Enumerations) of
-	{_,Int} -> true;
-	_ -> throw({error,{enumerated,Int,Atom}})
-    end;
-check_enum(DefVal, Val, _) ->
-    throw({error,{enumerated,DefVal,Val}}).
-
-
-check_restrictedstring(_, asn1_DEFAULT) ->
-    true;
 check_restrictedstring(Val, Val) ->
     true;
 check_restrictedstring([V|Rest1], [V|Rest2]) ->
@@ -270,7 +196,15 @@ check_restrictedstring({V1,V2,V3,V4}, [V1,V2,V3,V4]) ->
 check_restrictedstring([V1,V2,V3,V4], {V1,V2,V3,V4}) ->
     true;
 %% character string list
-check_restrictedstring(V1, V2) when is_list(V1), is_tuple(V2) ->
-    check_restrictedstring(V1, tuple_to_list(V2));
-check_restrictedstring(V1, V2) ->
-    throw({error,{restricted,string,V1,V2}}).
+check_restrictedstring(V1, V2) when is_tuple(V1) ->
+    check_restrictedstring(tuple_to_list(V1), V2);
+check_restrictedstring(_, _) ->
+    throw(false).
+
+check_literal_sof(Value, Default) ->
+    case lists:sort(Value) of
+	Default ->
+	    true;
+	_ ->
+	    throw(false)
+    end.
diff --git a/lib/asn1/src/asn1rtt_ext.erl b/lib/asn1/src/asn1rtt_ext.erl
index 46adb2007d..3bf01823db 100644
--- a/lib/asn1/src/asn1rtt_ext.erl
+++ b/lib/asn1/src/asn1rtt_ext.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -38,7 +39,7 @@ transform_to_EXTERNAL1990([{'context-negotiation',Context_negot}|Rest], Acc) ->
 transform_to_EXTERNAL1990([asn1_NOVALUE|Rest], Acc) ->
     transform_to_EXTERNAL1990(Rest, [asn1_NOVALUE|Acc]);
 transform_to_EXTERNAL1990([Data_val_desc,Data_value], Acc)
-  when is_list(Data_value)->
+    when is_list(Data_value); is_binary(Data_value) ->
     list_to_tuple(lists:reverse([{'octet-aligned',Data_value},
 				 Data_val_desc|Acc]));
 transform_to_EXTERNAL1990([Data_val_desc,Data_value], Acc)
diff --git a/lib/asn1/src/asn1rtt_per.erl b/lib/asn1/src/asn1rtt_per.erl
index 9f4b7500d8..753a38aa6e 100644
--- a/lib/asn1/src/asn1rtt_per.erl
+++ b/lib/asn1/src/asn1rtt_per.erl
@@ -1,79 +1,25 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
 -module(asn1rtt_per).
 
--export([setext/1, fixextensions/2,
-	 skipextensions/3,
-	 set_choice/3,encode_integer/2,
-	 encode_small_number/1,
-	 encode_constrained_number/2,
-	 encode_length/1,
-	 encode_length/2,
-	 encode_bit_string/3,
-	 encode_object_identifier/1,
-	 encode_relative_oid/1,
-	 complete/1,
-	 encode_open_type/1,
-	 encode_GeneralString/2,
-	 encode_GraphicString/2,
-	 encode_TeletexString/2,
-	 encode_VideotexString/2,
-	 encode_ObjectDescriptor/2,
-	 encode_UTF8String/1,
-	 encode_octet_string/2,
-	 encode_known_multiplier_string/4,
-	 octets_to_complete/2]).
-
--define('16K',16384).
--define('32K',32768).
--define('64K',65536).
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% setext(true|false) ->  CompleteList
-%%
-
-setext(false) ->
-    [0];
-setext(true) ->
-    [1].
-
-fixextensions({ext,ExtPos,ExtNum},Val) ->
-    case fixextensions(ExtPos,ExtNum+ExtPos,Val,0) of
-	0 -> [];
-	ExtBits ->
-	    [encode_small_length(ExtNum)|pre_complete_bits(ExtNum,ExtBits)]
-    end.
-
-fixextensions(Pos,MaxPos,_,Acc) when Pos >= MaxPos ->
-    Acc;
-fixextensions(Pos,ExtPos,Val,Acc) ->
-    Bit = case catch(element(Pos+1,Val)) of
-	      asn1_NOVALUE ->
-		  0;
-	      asn1_NOEXTVALUE ->
-		  0;
-	      {'EXIT',_} ->
-		  0;
-	      _ ->
-		  1
-	  end,
-    fixextensions(Pos+1,ExtPos,Val,(Acc bsl 1)+Bit).
+-export([skipextensions/3,complete/1]).
 
 skipextensions(Bytes0, Nr, ExtensionBitstr) when is_bitstring(ExtensionBitstr) ->
     Prev = Nr - 1,
@@ -95,270 +41,6 @@ align(BitStr) when is_bitstring(BitStr) ->
     <<_:AlignBits,Rest/binary>> = BitStr,
     Rest.
 
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% set_choice(Alt,Choices,Altnum) -> ListofBitSettings
-%% Alt = atom()
-%% Altnum = integer() | {integer(),integer()}% number of alternatives
-%% Choices = [atom()] | {[atom()],[atom()]}
-%% When Choices is a tuple the first list is the Rootset and the
-%% second is the Extensions and then Altnum must also be a tuple with the
-%% lengths of the 2 lists
-%%
-set_choice(Alt,{L1,L2},{Len1,_Len2}) ->
-    case set_choice_tag(Alt,L1) of
-	N when is_integer(N), Len1 > 1 ->
-	    [0,				% the value is in the root set
-	     encode_constrained_number({0,Len1-1},N)];
-	N when is_integer(N) ->
-	    [0];	      % no encoding if only 0 or 1 alternative
-	false ->
-	    [1,					% extension value
-	     case set_choice_tag(Alt, L2) of
-		 N2 when is_integer(N2) ->
-		     encode_small_number(N2);
-		 false ->
-		     unknown_choice_alt
-	     end]
-    end;
-set_choice(Alt, L, Len) ->
-    case set_choice_tag(Alt, L) of
-	N when is_integer(N), Len > 1 ->
-	    encode_constrained_number({0,Len-1},N);
-	N when is_integer(N) ->
-	    [];		      % no encoding if only 0 or 1 alternative
-	false ->
-	    [unknown_choice_alt]
-    end.
-
-set_choice_tag(Alt,Choices) ->
-    set_choice_tag(Alt,Choices,0).
-
-set_choice_tag(Alt,[Alt|_Rest],Tag) ->
-    Tag;
-set_choice_tag(Alt,[_H|Rest],Tag) ->
-    set_choice_tag(Alt,Rest,Tag+1);
-set_choice_tag(_Alt,[],_Tag) ->
-    false.
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_open_type(Constraint, Value) -> CompleteList
-%% Value = list of bytes of an already encoded value (the list must be flat)
-%%         | binary
-%% Contraint = not used in this version
-%%
-encode_open_type(Val) ->
-    case byte_size(Val) of
-	Size when Size > 255 ->
-	    [encode_length(Size),21,<<Size:16>>,Val]; % octets implies align
-	Size ->
-	    [encode_length(Size),20,Size,Val]
-    end.
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_integer(Constraint, Value) -> CompleteList
-%%
-encode_integer([{Rc,_Ec}],Val) when is_tuple(Rc) ->
-    try
-	[0|encode_integer([Rc], Val)]
-    catch
-	_:{error,{asn1,_}} ->
-	    [1|encode_unconstrained_number(Val)]
-    end;
-encode_integer([], Val) ->
-    encode_unconstrained_number(Val);
-%% The constraint is the effective constraint, and in this case is a number
-encode_integer([{'SingleValue',V}], V) ->
-    [];
-encode_integer([{'ValueRange',{Lb,Ub}=VR,Range,PreEnc}],Val)
-  when Val >= Lb, Ub >= Val ->
-    %% this case when NamedNumberList
-    encode_constrained_number(VR, Range, PreEnc, Val);
-encode_integer([{'ValueRange',{Lb,'MAX'}}], Val) when Lb =< Val ->
-    encode_semi_constrained_number(Lb, Val);
-encode_integer([{'ValueRange',{'MIN',_}}], Val) ->
-    encode_unconstrained_number(Val);
-encode_integer([{'ValueRange',VR={_Lb,_Ub}}], Val) ->
-    encode_constrained_number(VR, Val);
-encode_integer(_,Val) ->
-    exit({error,{asn1,{illegal_value,Val}}}).
-
-
-%% X.691:10.6 Encoding of a normally small non-negative whole number
-%% Use this for encoding of CHOICE index if there is an extension marker in
-%% the CHOICE
-encode_small_number(Val) when Val < 64 ->
-    [10,7,Val];
-encode_small_number(Val) ->
-    [1|encode_semi_constrained_number(0, Val)].
-
-%% X.691:10.7 Encoding of a semi-constrained whole number
-encode_semi_constrained_number(Lb, Val) ->
-    Val2 = Val - Lb,
-    Oct = eint_positive(Val2),
-    Len = length(Oct),
-    if
-	Len < 128 ->
-	    [20,Len+1,Len|Oct];
-	Len < 256 ->
-	    [encode_length(Len),20,Len|Oct];
-	true ->
-	    [encode_length(Len),21,<<Len:16>>|Oct]
-    end.
-
-encode_constrained_number({Lb,_Ub},_Range,{bits,N},Val) ->
-    Val2 = Val-Lb,
-    [10,N,Val2];
-encode_constrained_number({Lb,_Ub},_Range,{octets,N},Val) when N < 256->
-    %% N is 8 or 16 (1 or 2 octets)
-    Val2 = Val-Lb,
-    [20,N,Val2];
-encode_constrained_number({Lb,_Ub},_Range,{octets,N},Val) -> % N>255
-    %% N is 8 or 16 (1 or 2 octets)
-    Val2 = Val-Lb,
-    [21,<<N:16>>,Val2];
-encode_constrained_number({Lb,_Ub},Range,_,Val) ->
-    Val2 = Val-Lb,
-    if
-	Range =< 16#1000000  -> % max 3 octets
-	    Octs = eint_positive(Val2),
-	    L = length(Octs),
-	    [encode_length({1,3},L),[20,L,Octs]];
-	Range =< 16#100000000  -> % max 4 octets
-	    Octs = eint_positive(Val2),
-	    L = length(Octs),
-	    [encode_length({1,4},L),[20,L,Octs]];
-	Range =< 16#10000000000  -> % max 5 octets
-	    Octs = eint_positive(Val2),
-	    L = length(Octs),
-	    [encode_length({1,5},L),[20,L,Octs]];
-	true  ->
-	    exit({not_supported,{integer_range,Range}})
-    end.
-
-encode_constrained_number({Lb,Ub}, Val) when Val >= Lb, Ub >= Val ->
-    Range = Ub - Lb + 1,
-    Val2 = Val - Lb,
-    if
-	Range  == 1 -> [];
-	Range  == 2 ->
-	    [Val2];
-	Range  =< 4 ->
-	    [10,2,Val2];
-	Range  =< 8 ->
-	    [10,3,Val2];
-	Range  =< 16 ->
-	    [10,4,Val2];
-	Range  =< 32 ->
-	    [10,5,Val2];
-	Range  =< 64 ->
-	    [10,6,Val2];
-	Range  =< 128 ->
-	    [10,7,Val2];
-	Range  =< 255 ->
-	    [10,8,Val2];
-	Range  =< 256 ->
-	    [20,1,Val2];
-	Range  =< 65536 ->
-	    [20,2,<<Val2:16>>];
-	Range =< (1 bsl (255*8))  ->
-            Octs = binary:encode_unsigned(Val2),
-            RangeOcts = binary:encode_unsigned(Range - 1),
-            OctsLen = byte_size(Octs),
-            RangeOctsLen = byte_size(RangeOcts),
-            LengthBitsNeeded = minimum_bits(RangeOctsLen - 1),
-            [10,LengthBitsNeeded,OctsLen-1,20,OctsLen,Octs];
-	true  ->
-	    exit({not_supported,{integer_range,Range}})
-    end;
-encode_constrained_number({_,_},Val) ->
-    exit({error,{asn1,{illegal_value,Val}}}).
-
-%% For some reason the minimum bits needed in the length field in
-%% the encoding of constrained whole numbers must always be at least 2?
-minimum_bits(N) when N < 4 -> 2;
-minimum_bits(N) when N < 8 -> 3;
-minimum_bits(N) when N < 16 -> 4;
-minimum_bits(N) when N < 32 -> 5;
-minimum_bits(N) when N < 64 -> 6;
-minimum_bits(N) when N < 128 -> 7;
-minimum_bits(_N) -> 8.
-
-%% X.691:10.8 Encoding of an unconstrained whole number
-
-encode_unconstrained_number(Val) ->
-    Oct = if
-	      Val >= 0 ->
-		  eint(Val, []);
-	      true ->
-		  enint(Val, [])
-	  end,
-    Len = length(Oct),
-    if
-        Len < 128 ->
-            [20,Len + 1,Len|Oct];
-        Len < 256 ->
-            [20,Len + 2,<<2:2,Len:14>>|Oct];
-        true ->
-            [encode_length(Len),21,<<Len:16>>|Oct]
-    end.
-
-%% used for positive Values which don't need a sign bit
-%% returns a list
-eint_positive(Val) ->
-    case eint(Val,[]) of
-	[0,B1|T] ->
-	    [B1|T];
-	T ->
-	    T
-    end.
-
-
-eint(0, [B|Acc]) when B < 128 ->
-    [B|Acc];
-eint(N, Acc) ->
-    eint(N bsr 8, [N band 16#ff| Acc]).
-
-enint(-1, [B1|T]) when B1 > 127 ->
-    [B1|T];
-enint(N, Acc) ->
-    enint(N bsr 8, [N band 16#ff|Acc]).
-
-%% X.691:10.9 Encoding of a length determinant
-%%encode_small_length(undefined,Len) -> % null means no UpperBound
-%%    encode_small_number(Len).
-
-%% X.691:10.9.3.5
-%% X.691:10.9.3.7
-encode_length(Len) ->				% unconstrained
-    if
-	Len < 128 ->
-	    [20,1,Len];
-	Len < 16384 ->
-	    <<20,2,2:2,Len:14>>;
-	true  -> % should be able to endode length >= 16384 i.e. fragmented length
-	    exit({error,{asn1,{encode_length,{nyi,above_16k}}}})
-    end.
-
-encode_length({C,[]}, Len) ->
-    case C of
-	{Lb,Ub}=Vr when Lb =< Len, Len =< Ub ->
-	    [0|encode_constrained_number(Vr, Len)];
-	_ ->
-	    [1|encode_length(Len)]
-    end;
-encode_length(Len, Len) ->
-    [];
-encode_length(Vr, Len) ->
-    encode_constrained_number(Vr, Len).
-
-%% X.691 10.9.3.4 (only used for length of bitmap that prefixes extension
-%% additions in a sequence or set
-encode_small_length(Len) when Len =< 64 ->
-    [10,7,Len-1];
-encode_small_length(Len) ->
-    [1,encode_length(Len)].
-
-
 decode_length(Buffer)  -> % un-constrained
     case align(Buffer) of
 	<<0:1,Oct:7,Rest/binary>> ->
@@ -370,511 +52,70 @@ decode_length(Buffer)  -> % un-constrained
 	    exit({error,{asn1,{decode_length,{nyi,above_16k}}}})
     end.
 
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% bitstring NamedBitList
-%% Val can be  of:
-%% - [identifiers] where only named identifers are set to one,
-%%   the Constraint must then have some information of the
-%%   bitlength.
-%% - [list of ones and zeroes] all bits
-%% - integer value representing the bitlist
-%% C is constraint Len, only valid when identifiers
-
-
-%% when the value is a list of {Unused,BinBits}, where
-%% Unused = integer(),
-%% BinBits = binary().
-
-encode_bit_string(C, Bits, NamedBitList) when is_bitstring(Bits) ->
-    PadLen = (8 - (bit_size(Bits) band 7)) band 7,
-    Compact = {PadLen,<<Bits/bitstring,0:PadLen>>},
-    encode_bin_bit_string(C, Compact, NamedBitList);
-encode_bit_string(C, {Unused,BinBits}=Bin, NamedBitList)
-  when is_integer(Unused), is_binary(BinBits) ->
-    encode_bin_bit_string(C,Bin,NamedBitList);
-
-%% when the value is a list of named bits
-
-encode_bit_string(C, LoNB=[FirstVal | _RestVal], NamedBitList) when is_atom(FirstVal) ->
-    ToSetPos = get_all_bitposes(LoNB, NamedBitList, []),
-    BitList = make_and_set_list(ToSetPos,0),
-    encode_bit_string(C,BitList,NamedBitList);% consider the constraint
-
-encode_bit_string(C, BL=[{bit,_} | _RestVal], NamedBitList) ->
-    ToSetPos = get_all_bitposes(BL, NamedBitList, []),
-    BitList = make_and_set_list(ToSetPos,0),
-    encode_bit_string(C,BitList,NamedBitList);
-
-%% when the value is a list of ones and zeroes
-encode_bit_string(Int, BitListValue, _)
-  when is_list(BitListValue),is_integer(Int),Int =< 16 ->
-    %% The type is constrained by a single value size constraint
-    %% range_check(Int,length(BitListValue)),
-    [40,Int,length(BitListValue),BitListValue];
-encode_bit_string(Int, BitListValue, _)
-  when is_list(BitListValue),is_integer(Int), Int =< 255 ->
-    %% The type is constrained by a single value size constraint
-    %% range_check(Int,length(BitListValue)),
-    [2,40,Int,length(BitListValue),BitListValue];
-encode_bit_string(Int, BitListValue, _)
-  when is_list(BitListValue),is_integer(Int), Int < ?'64K' ->
-    {Code,DesiredLength,Length} =
-	case length(BitListValue) of
-	    B1 when B1 > Int ->
-		exit({error,{'BIT_STRING_length_greater_than_SIZE',
-			     Int,BitListValue}});
-	    B1 when B1 =< 255,Int =< 255 ->
-		{40,Int,B1};
-	    B1 when B1 =< 255 ->
-		{42,<<Int:16>>,B1};
-	    B1 ->
-		{43,<<Int:16>>,<<B1:16>>}
-	end,
-    %% The type is constrained by a single value size constraint
-    [2,Code,DesiredLength,Length,BitListValue];
-encode_bit_string(no, BitListValue,[])
-  when is_list(BitListValue) ->
-    [encode_length(length(BitListValue)),
-     2|BitListValue];
-encode_bit_string({{Fix,Fix},Ext}, BitListValue,[])
-  when is_integer(Fix), is_list(Ext) ->
-    case length(BitListValue) of
-	Len when Len =< Fix ->
-	    [0|encode_bit_string(Fix, BitListValue, [])];
-	_ ->
-	    [1|encode_bit_string(no, BitListValue, [])]
-    end;
-encode_bit_string(C, BitListValue,[])
-  when is_list(BitListValue) ->
-    [encode_length(C, length(BitListValue)),
-     2|BitListValue];
-encode_bit_string(no, BitListValue,_NamedBitList)
-  when is_list(BitListValue) ->
-    %% this case with an unconstrained BIT STRING can be made more efficient
-    %% if the complete driver can take a special code so the length field
-    %% is encoded there.
-    NewBitLVal = lists:reverse(lists:dropwhile(fun(0)->true;(1)->false end,
-					    lists:reverse(BitListValue))),
-    [encode_length(length(NewBitLVal)),2|NewBitLVal];
-encode_bit_string({{Fix,Fix},Ext}, BitListValue, NamedBitList)
-  when is_integer(Fix), is_list(Ext) ->
-    case length(BitListValue) of
-	Len when Len =< Fix ->
-	    [0|encode_bit_string(Fix, BitListValue, NamedBitList)];
-	_ ->
-	    [1|encode_bit_string(no, BitListValue, NamedBitList)]
-    end;
-encode_bit_string(C, BitListValue, _NamedBitList)
-  when is_list(BitListValue) ->			% C = {_,'MAX'}
-    NewBitLVal = bit_string_trailing_zeros(BitListValue, C),
-    [encode_length(C, length(NewBitLVal)),2|NewBitLVal];
-
-
-%% when the value is an integer
-encode_bit_string(C, IntegerVal, NamedBitList) when is_integer(IntegerVal)->
-    BitList = int_to_bitlist(IntegerVal),
-    encode_bit_string(C,BitList,NamedBitList).
-
-bit_string_trailing_zeros(BitList,C) when is_integer(C) ->
-    bit_string_trailing_zeros1(BitList,C,C);
-bit_string_trailing_zeros(BitList,{Lb,Ub}) when is_integer(Lb) ->
-    bit_string_trailing_zeros1(BitList,Lb,Ub);
-bit_string_trailing_zeros(BitList,{{Lb,Ub},_}) when is_integer(Lb) ->
-    bit_string_trailing_zeros1(BitList,Lb,Ub);
-bit_string_trailing_zeros(BitList,_) ->
-    BitList.
-
-bit_string_trailing_zeros1(BitList,Lb,Ub) ->
-    case length(BitList) of
-	Lb -> BitList;
-	B when B < Lb -> BitList++lists:duplicate(Lb-B, 0);
-	D -> F = fun(L,LB,LB,_,_)->lists:reverse(L);
-		    ([0|R],L1,LB,UB,Fun)->Fun(R,L1-1,LB,UB,Fun);
-		    (L,L1,_,UB,_)when L1 =< UB -> lists:reverse(L);
-		    (_,_L1,_,_,_) ->exit({error,{list_length_BIT_STRING,
-						 BitList}}) end,
-	     F(lists:reverse(BitList),D,Lb,Ub,F)
-    end.
-
-%% encode_bin_bit_string/3, when value is a tuple of Unused and BinBits.
-%% Unused = integer(),i.e. number unused bits in least sign. byte of
-%% BinBits = binary().
-encode_bin_bit_string(C, {Unused,BinBits}, _NamedBitList)
-  when is_integer(C),C=<16 ->
-    range_check(C, bit_size(BinBits) - Unused),
-    [45,C,byte_size(BinBits),BinBits];
-encode_bin_bit_string(C, {Unused,BinBits}, _NamedBitList)
-  when is_integer(C), C =< 255 ->
-    range_check(C, bit_size(BinBits) - Unused),
-    [2,45,C,byte_size(BinBits),BinBits];
-encode_bin_bit_string(C, {Unused,BinBits}, _NamedBitList)
-  when is_integer(C), C =< 65535 ->
-    range_check(C, bit_size(BinBits) - Unused),
-    case byte_size(BinBits) of
-	Size when Size =< 255 ->
-	    [2,46,<<C:16>>,Size,BinBits];
-	Size ->
-	    [2,47,<<C:16>>,<<Size:16>>,BinBits]
-    end;
-encode_bin_bit_string(C,UnusedAndBin={_,_},NamedBitList) ->
-    {Unused1,Bin1} =
-	%% removes all trailing bits if NamedBitList is not empty
-	remove_trailing_bin(NamedBitList,UnusedAndBin),
-    case C of
-	{Lb,Ub} when is_integer(Lb),is_integer(Ub) ->
-	    Size = byte_size(Bin1),
-	    [encode_length({Lb,Ub}, Size*8 - Unused1),
-	     2,octets_unused_to_complete(Unused1,Size,Bin1)];
-	no ->
-	    Size = byte_size(Bin1),
-	    [encode_length(Size*8 - Unused1),
-	     2|octets_unused_to_complete(Unused1, Size, Bin1)];
-	{{Fix,Fix},Ext} when is_integer(Fix),is_list(Ext) ->
-	    case byte_size(Bin1)*8 - Unused1 of
-		Size when Size =< Fix  ->
-		    [0|encode_bin_bit_string(Fix,UnusedAndBin,NamedBitList)];
-		_Size ->
-		    [1|encode_bin_bit_string(no,UnusedAndBin,NamedBitList)]
-	    end;
-	Sc ->
-	    Size = byte_size(Bin1),
-	    [encode_length(Sc, Size*8 - Unused1),
-	     2|octets_unused_to_complete(Unused1,Size,Bin1)]
-    end.
-
-range_check(C,C) when is_integer(C) ->
-    ok;
-range_check(C1,C2) when is_integer(C1) ->
-    exit({error,{asn1,{bit_string_out_of_range,{C1,C2}}}}).
-
-remove_trailing_bin([], {Unused,Bin}) ->
-    {Unused,Bin};
-remove_trailing_bin(_NamedNumberList,{_Unused,<<>>}) ->
-    {0,<<>>};
-remove_trailing_bin(NamedNumberList, {_Unused,Bin}) ->
-    Size = byte_size(Bin)-1,
-    <<Bfront:Size/binary, LastByte:8>> = Bin,
-    %% clear the Unused bits to be sure
-    Unused1 = trailingZeroesInNibble(LastByte band 15),
-    Unused2 =
-	case Unused1 of
-	    4 ->
-		4 + trailingZeroesInNibble(LastByte bsr 4);
-	    _ -> Unused1
-	end,
-    case Unused2 of
-	8 ->
-	    remove_trailing_bin(NamedNumberList,{0,Bfront});
-	_ ->
-	    {Unused2,Bin}
-    end.
-
-
-trailingZeroesInNibble(0) ->
-    4;
-trailingZeroesInNibble(1) ->
-    0;
-trailingZeroesInNibble(2) ->
-    1;
-trailingZeroesInNibble(3) ->
-    0;
-trailingZeroesInNibble(4) ->
-    2;
-trailingZeroesInNibble(5) ->
-    0;
-trailingZeroesInNibble(6) ->
-    1;
-trailingZeroesInNibble(7) ->
-    0;
-trailingZeroesInNibble(8) ->
-    3;
-trailingZeroesInNibble(9) ->
-    0;
-trailingZeroesInNibble(10) ->
-    1;
-trailingZeroesInNibble(11) ->
-    0;
-trailingZeroesInNibble(12) -> %#1100
-    2;
-trailingZeroesInNibble(13) ->
-    0;
-trailingZeroesInNibble(14) ->
-    1;
-trailingZeroesInNibble(15) ->
-    0.
-
-
-%%%%%%%%%%%%%%%
-%%
-
-int_to_bitlist(Int) when is_integer(Int), Int > 0 ->
-    [Int band 1 | int_to_bitlist(Int bsr 1)];
-int_to_bitlist(0) ->
-    [].
-
-
-%%%%%%%%%%%%%%%%%%
-%% get_all_bitposes([list of named bits to set], named_bit_db, []) ->
-%%   [sorted_list_of_bitpositions_to_set]
-
-get_all_bitposes([{bit,ValPos}|Rest], NamedBitList, Ack) ->
-    get_all_bitposes(Rest, NamedBitList, [ValPos | Ack ]);
-
-get_all_bitposes([Val | Rest], NamedBitList, Ack) ->
-    case lists:keyfind(Val, 1, NamedBitList) of
-	{_ValName, ValPos} ->
-	    get_all_bitposes(Rest, NamedBitList, [ValPos | Ack]);
-	false ->
-	    exit({error,{asn1, {bitstring_namedbit, Val}}})
-    end;
-get_all_bitposes([], _NamedBitList, Ack) ->
-    lists:sort(Ack).
-
-%%%%%%%%%%%%%%%%%%
-%% make_and_set_list([list of positions to set to 1])->
-%% returns list with all in SetPos set.
-%% in positioning in list the first element is 0, the second 1 etc.., but
-%%
-
-make_and_set_list([XPos|SetPos], XPos) ->
-    [1 | make_and_set_list(SetPos, XPos + 1)];
-make_and_set_list([Pos|SetPos], XPos) ->
-    [0 | make_and_set_list([Pos | SetPos], XPos + 1)];
-make_and_set_list([], _) ->
-    [].
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% X.691:16
-%% encode_octet_string(Constraint, Val)
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-encode_octet_string({{Sv,Sv},Ext}=SZ, Val) when is_list(Ext), Sv =< 2 ->
-    Len = length(Val),
-    try
-        case encode_length(SZ, Len) of
-            [0|_]=EncLen ->
-                [EncLen,45,Sv*8,Sv,Val];
-            [_|_]=EncLen ->
-                [EncLen|octets_to_complete(Len, Val)]
-        end
-    catch
-	exit:{error,{asn1,{encode_length,_}}} ->
-	    encode_fragmented_octet_string(Val)
-    end;
-encode_octet_string({_,_}=SZ, Val) ->
-    Len = length(Val),
-    try
-	[encode_length(SZ, Len),2|octets_to_complete(Len, Val)]
-    catch
-	exit:{error,{asn1,{encode_length,_}}} ->
-	    encode_fragmented_octet_string(Val)
-    end;
-encode_octet_string(Sv, Val) when is_integer(Sv) ->
-    encode_fragmented_octet_string(Val);
-encode_octet_string(no, Val) ->
-    Len = length(Val),
-    try
-	[encode_length(Len),2|octets_to_complete(Len, Val)]
-    catch
-	exit:{error,{asn1,{encode_length,_}}} ->
-	    encode_fragmented_octet_string(Val)
-    end.
-
-encode_fragmented_octet_string(Val) ->
-    Bin = iolist_to_binary(Val),
-    efos_1(Bin).
-
-efos_1(<<B1:16#C000/binary,B2:16#4000/binary,T/binary>>) ->
-    [20,1,<<3:2,4:6>>,
-     octets_to_complete(16#C000, B1),
-     octets_to_complete(16#4000, B2)|efos_1(T)];
-efos_1(<<B:16#C000/binary,T/binary>>) ->
-    [20,1,<<3:2,3:6>>,octets_to_complete(16#C000, B)|efos_1(T)];
-efos_1(<<B:16#8000/binary,T/binary>>) ->
-    [20,1,<<3:2,2:6>>,octets_to_complete(16#8000, B)|efos_1(T)];
-efos_1(<<B:16#4000/binary,T/binary>>) ->
-    [20,1,<<3:2,1:6>>,octets_to_complete(16#4000, B)|efos_1(T)];
-efos_1(<<>>) ->
-    [20,1,0];
-efos_1(<<B/bitstring>>) ->
-    Len = byte_size(B),
-    [encode_length(Len)|octets_to_complete(Len, B)].
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% Restricted char string types
-%% (NumericString, PrintableString,VisibleString,IA5String,BMPString,UniversalString)
-%% X.691:26 and X.680:34-36
-
-encode_restricted_string(Val) when is_list(Val)->
-    Len = length(Val),
-    [encode_length(Len)|octets_to_complete(Len, Val)].
-
-encode_known_multiplier_string(SizeC, NumBits, CharOutTab, Val) ->
-    Result = chars_encode2(Val, NumBits, CharOutTab),
-    case SizeC of
-	Ub when is_integer(Ub), Ub*NumBits < 16  ->
-	    Result;
-	Ub when is_integer(Ub) ->
-	    [2,Result];
-	{{_,Ub},Ext}=SZ when is_list(Ext) ->
-	    Len = length(Val),
-	    case encode_length(SZ, Len) of
-		[0|_]=EncLen when Ub*NumBits < 16 ->
-		    [EncLen,45,Len*NumBits,Len,Val];
-		[_|_]=EncLen ->
-		    [EncLen,2|Result]
-	    end;
-	{_,Ub}=Range ->
-	    [encode_length(Range, length(Val))|
-	     if
-		 Ub*NumBits < 16 -> Result;
-		 true -> [2|Result]
-	     end];
-	no  ->
-	    [encode_length(length(Val)),2,Result]
-    end.
-
-encode_GeneralString(_C,Val) ->
-    encode_restricted_string(Val).
-
-encode_GraphicString(_C,Val) ->
-    encode_restricted_string(Val).
-
-encode_ObjectDescriptor(_C,Val) ->
-    encode_restricted_string(Val).
-
-encode_TeletexString(_C,Val) -> % equivalent with T61String
-    encode_restricted_string(Val).
-
-encode_VideotexString(_C,Val) ->
-    encode_restricted_string(Val).
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% chars_encode(C,StringType,Value) -> ValueList
-%%
-%% encodes chars according to the per rules taking the constraint
-%% PermittedAlphabet into account.
-%%
-%% This function only encodes the value part and NOT the length.
-
-chars_encode2([H|T],NumBits,T1={Min,Max,notab}) when  H =< Max, H >= Min ->
-    [pre_complete_bits(NumBits,H-Min)|chars_encode2(T,NumBits,T1)];
-chars_encode2([H|T],NumBits,T1={Min,Max,Tab}) when H =< Max, H >= Min ->
-    [pre_complete_bits(NumBits,exit_if_false(H,element(H-Min+1,Tab)))|
-     chars_encode2(T,NumBits,T1)];
-chars_encode2([{A,B,C,D}|T],NumBits,T1={Min,_Max,notab}) ->
-    %% no value range check here (ought to be, but very expensive)
-    [pre_complete_bits(NumBits,
-			       ((((((A bsl 8)+B) bsl 8)+C) bsl 8)+D)-Min)|
-     chars_encode2(T,NumBits,T1)];
-chars_encode2([H={A,B,C,D}|T],NumBits,{Min,Max,Tab}) ->
-    %% no value range check here (ought to be, but very expensive)
-    [pre_complete_bits(NumBits,exit_if_false(H,element(((((((A bsl 8)+B) bsl 8)+C) bsl 8)+D)-Min,Tab)))|chars_encode2(T,NumBits,{Min,Max,notab})];
-chars_encode2([H|_T],_NumBits,{_Min,_Max,_Tab}) ->
-    exit({error,{asn1,{illegal_char_value,H}}});
-chars_encode2([],_,_) ->
-    [].
-
-exit_if_false(V,false)->
-    exit({error,{asn1,{"illegal value according to Permitted alphabet constraint",V}}});
-exit_if_false(_,V) ->V.
-
-pre_complete_bits(NumBits,Val) when NumBits =< 8 ->
-    [10,NumBits,Val];
-pre_complete_bits(NumBits,Val) when NumBits =< 16 ->
-    [10,NumBits-8,Val bsr 8,10,8,(Val band 255)];
-pre_complete_bits(NumBits,Val) when NumBits =< 2040 -> % 255 * 8
-    Unused = (8 - (NumBits rem 8)) rem 8,
-    Len = NumBits + Unused,
-    [30,Unused,Len div 8,<<(Val bsl Unused):Len>>].
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_UTF8String(Val) -> CompleteList
-%% Val -> <<utf8encoded binary>>
-%% CompleteList -> [apropriate codes and values for driver complete]
-%%
-encode_UTF8String(Val) when is_binary(Val) ->
-    Sz = byte_size(Val),
-    [encode_length(Sz),octets_to_complete(Sz, Val)];
-encode_UTF8String(Val) ->
-    encode_UTF8String(list_to_binary(Val)).
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_object_identifier(Val) -> CompleteList
-%% encode_object_identifier({Name,Val}) -> CompleteList
-%% Val -> {Int1,Int2,...,IntN} % N >= 2
-%% Name -> atom()
-%% Int1 -> integer(0..2)
-%% Int2 -> integer(0..39) when Int1 (0..1) else integer()
-%% Int3-N -> integer()
-%% CompleteList -> [{bits,8,Val}|{octets,Ol}|align|...]
-%%
-encode_object_identifier(Val) ->
-    OctetList = e_object_identifier(Val),
-    Octets = list_to_binary(OctetList),
-    Sz = byte_size(Octets),
-    [encode_length(Sz),
-     octets_to_complete(Sz, Octets)].
-
-e_object_identifier({'OBJECT IDENTIFIER',V}) ->
-    e_object_identifier(V);
-e_object_identifier(V) when is_tuple(V) ->
-    e_object_identifier(tuple_to_list(V));
-
-%% E1 = 0|1|2 and (E2 < 40 when E1 = 0|1)
-e_object_identifier([E1,E2|Tail]) when E1 >= 0, E1 < 2, E2 < 40 ; E1==2 ->
-    Head = 40*E1 + E2,  % weird
-    e_object_elements([Head|Tail],[]);
-e_object_identifier(Oid=[_,_|_Tail]) ->
-    exit({error,{asn1,{'illegal_value',Oid}}}).
-
-e_object_elements([],Acc) ->
-    lists:reverse(Acc);
-e_object_elements([H|T],Acc) ->
-    e_object_elements(T,[e_object_element(H)|Acc]).
-
-e_object_element(Num) when Num < 128 ->
-    [Num];
-e_object_element(Num) ->
-    [e_o_e(Num bsr 7)|[Num band 2#1111111]].
-e_o_e(Num) when Num < 128 ->
-    Num bor 2#10000000;
-e_o_e(Num) ->
-    [e_o_e(Num bsr 7)|[(Num band 2#1111111) bor 2#10000000]].
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_relative_oid(Val) -> CompleteList
-%% encode_relative_oid({Name,Val}) -> CompleteList
-encode_relative_oid(Val) when is_tuple(Val) ->
-    encode_relative_oid(tuple_to_list(Val));
-encode_relative_oid(Val) when is_list(Val) ->
-    Octets = list_to_binary([e_object_element(X)||X <- Val]),
-    Sz = byte_size(Octets),
-    [encode_length(Sz)|octets_to_complete(Sz, Octets)].
-
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% complete(InList) -> ByteList
 %% Takes a coded list with bits and bytes and converts it to a list of bytes
 %% Should be applied as the last step at encode of a complete ASN.1 type
 %%
 
-complete(L) ->
-    case asn1rt_nif:encode_per_complete(L) of
+complete(L0) ->
+    L = complete(L0, []),
+    case list_to_bitstring(L) of
 	<<>> -> <<0>>;
 	Bin -> Bin
     end.
 
-octets_to_complete(Len,Val) when Len < 256 ->
-    [20,Len,Val];
-octets_to_complete(Len,Val) ->
-    [21,<<Len:16>>,Val].
-
-octets_unused_to_complete(Unused,Len,Val) when Len < 256 ->
-    [30,Unused,Len,Val];
-octets_unused_to_complete(Unused,Len,Val) ->
-    [31,Unused,<<Len:16>>,Val].
+complete([], []) ->
+    [];
+complete([], [H|More]) ->
+    complete(H, More);
+complete([align|T], More) ->
+    complete(T, More);
+complete([[]|T], More) ->
+    complete(T, More);
+complete([[_|_]=H], More) ->
+    complete(H, More);
+complete([[_|_]=H|T], More) ->
+    complete(H, [T|More]);
+complete([H|T], More) when is_integer(H); is_binary(H) ->
+    [H|complete(T, More)];
+complete([H|T], More) ->
+    [H|complete(T, bit_size(H), More)];
+complete(Bin, More) when is_binary(Bin) ->
+    [Bin|complete([], More)];
+complete(Bin, More) ->
+    [Bin|complete([], bit_size(Bin), More)].
+
+complete([], Bits, []) ->
+    case Bits band 7 of
+	0 -> [];
+	N -> [<<0:(8-N)>>]
+    end;
+complete([], Bits, [H|More]) ->
+    complete(H, Bits, More);
+complete([align|T], Bits, More) ->
+    case Bits band 7 of
+	0 -> complete(T, More);
+	1 -> [<<0:7>>|complete(T, More)];
+	2 -> [<<0:6>>|complete(T, More)];
+	3 -> [<<0:5>>|complete(T, More)];
+	4 -> [<<0:4>>|complete(T, More)];
+	5 -> [<<0:3>>|complete(T, More)];
+	6 -> [<<0:2>>|complete(T, More)];
+	7 -> [<<0:1>>|complete(T, More)]
+    end;
+complete([[]|T], Bits, More) ->
+    complete(T, Bits, More);
+complete([[_|_]=H], Bits, More) ->
+    complete(H, Bits, More);
+complete([[_|_]=H|T], Bits, More) ->
+    complete(H, Bits, [T|More]);
+complete([H|T], Bits, More) when is_integer(H);
+				 is_binary(H) ->
+    [H|complete(T, Bits, More)];
+complete([H|T], Bits, More) ->
+    [H|complete(T, Bits+bit_size(H), More)];
+complete(Bin, Bits, More) when is_binary(Bin) ->
+    [Bin|complete([], Bits, More)];
+complete(Bin, Bits, More) ->
+    [Bin|complete([], Bits+bit_size(Bin), More)].
diff --git a/lib/asn1/src/asn1rtt_per_common.erl b/lib/asn1/src/asn1rtt_per_common.erl
index e7edc2b65f..3896cb7fa5 100644
--- a/lib/asn1/src/asn1rtt_per_common.erl
+++ b/lib/asn1/src/asn1rtt_per_common.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -28,7 +29,20 @@
 	 decode_chars/2,decode_chars/3,
 	 decode_chars_16bit/1,
 	 decode_big_chars/2,
-	 decode_oid/1,decode_relative_oid/1]).
+	 decode_oid/1,decode_relative_oid/1,
+	 encode_chars/2,encode_chars/3,
+	 encode_chars_compact_map/3,
+	 encode_chars_16bit/1,encode_big_chars/1,
+	 encode_fragmented/2,
+	 encode_oid/1,encode_relative_oid/1,
+	 encode_unconstrained_number/1,
+	 bitstring_from_positions/1,bitstring_from_positions/2,
+	 to_bitstring/1,to_bitstring/2,
+	 to_named_bitstring/1,to_named_bitstring/2,
+	 bs_drop_trailing_zeroes/1,adjust_trailing_zeroes/2,
+	 is_default_bitstring/3,is_default_bitstring/5,
+	 extension_bitmap/3,
+	 open_type_to_binary/1,legacy_open_type_to_binary/1]).
 
 -define('16K',16384).
 
@@ -90,6 +104,244 @@ decode_oid(Octets) ->
 decode_relative_oid(Octets) ->
     list_to_tuple(dec_subidentifiers(Octets, 0, [])).
 
+encode_chars(Val, NumBits) ->
+    << <<C:NumBits>> || C <- Val >>.
+
+encode_chars(Val, NumBits, {Lb,Tab}) ->
+    << <<(enc_char(C, Lb, Tab)):NumBits>> || C <- Val >>.
+
+encode_chars_compact_map(Val, NumBits, {Lb,Limit}) ->
+    << <<(enc_char_cm(C, Lb, Limit)):NumBits>> || C <- Val >>.
+
+encode_chars_16bit(Val) ->
+    L = [case C of
+	     {0,0,A,B} -> [A,B];
+	     C when is_integer(C) -> [0,C]
+	 end || C <- Val],
+    iolist_to_binary(L).
+
+encode_big_chars(Val) ->
+    L = [case C of
+	     {_,_,_,_} -> tuple_to_list(C);
+	     C when is_integer(C) -> [<<0,0,0>>,C]
+	 end || C <- Val],
+    iolist_to_binary(L).
+
+encode_fragmented(Bin, Unit) ->
+    encode_fragmented_1(Bin, Unit, 4).
+
+encode_oid(Val) when is_tuple(Val) ->
+    encode_oid(tuple_to_list(Val));
+encode_oid(Val) ->
+    iolist_to_binary(e_object_identifier(Val)).
+
+encode_relative_oid(Val) when is_tuple(Val) ->
+    encode_relative_oid(tuple_to_list(Val));
+encode_relative_oid(Val) when is_list(Val) ->
+    list_to_binary([e_object_element(X)||X <- Val]).
+
+encode_unconstrained_number(Val) when Val >= 0 ->
+    if
+	Val < 16#80 ->
+	    [1,Val];
+	Val < 16#100 ->
+	    [<<2,0>>,Val];
+	true ->
+	    case binary:encode_unsigned(Val) of
+		<<0:1,_/bitstring>>=Bin ->
+		    case byte_size(Bin) of
+			Sz when Sz < 128 ->
+			    [Sz,Bin];
+			Sz when Sz < 16384 ->
+			    [<<2:2,Sz:14>>,Bin]
+		    end;
+		<<1:1,_/bitstring>>=Bin ->
+		    case byte_size(Bin)+1 of
+			Sz when Sz < 128 ->
+			    [Sz,0,Bin];
+			Sz when Sz < 16384 ->
+			    [<<2:2,Sz:14,0:8>>,Bin]
+		    end
+	    end
+    end;
+encode_unconstrained_number(Val) ->
+    Oct = enint(Val, []),
+    Len = length(Oct),
+    if
+        Len < 128 ->
+            [Len|Oct];
+        Len < 16384 ->
+            [<<2:2,Len:14>>|Oct]
+    end.
+
+%% bitstring_from_positions([Position]) -> BitString
+%%  Given an unsorted list of bit positions (0..MAX), construct
+%%  a BIT STRING. The rightmost bit will always be a one.
+
+bitstring_from_positions([]) -> <<>>;
+bitstring_from_positions([_|_]=L0) ->
+    L1 = lists:sort(L0),
+    L = diff(L1, -1),
+    << <<1:(N+0)>> || N <- L >>.
+
+%% bitstring_from_positions([Position], Lb) -> BitString
+%%  Given an unsorted list of bit positions (0..MAX) and a lower bound
+%%  for the number of bits, construct BIT STRING (zero-padded on the
+%%  right side if needed).
+
+bitstring_from_positions(L0, Lb) ->
+    L1 = lists:sort(L0),
+    L = diff(L1, -1, Lb-1),
+    << <<B:(N+0)>> || {B,N} <- L >>.
+
+%% to_bitstring(Val) -> BitString
+%%    Val = BitString | {Unused,Binary} | [OneOrZero] | Integer
+%%  Given one of the possible representations for a BIT STRING,
+%%  return a bitstring (without adding or removing any zero bits
+%%  at the right end).
+
+to_bitstring({0,Bs}) when is_binary(Bs) ->
+    Bs;
+to_bitstring({Unused,Bs0}) when is_binary(Bs0) ->
+    Sz = bit_size(Bs0) - Unused,
+    <<Bs:Sz/bits,_/bits>> = Bs0,
+    Bs;
+to_bitstring(Bs) when is_bitstring(Bs) ->
+    Bs;
+to_bitstring(Int) when is_integer(Int), Int >= 0 ->
+    L = int_to_bitlist(Int),
+    << <<B:1>> || B <- L >>;
+to_bitstring(L) when is_list(L) ->
+    << <<B:1>> || B <- L >>.
+
+%% to_bitstring(Val, Lb) -> BitString
+%%    Val = BitString | {Unused,Binary} | [OneOrZero] | Integer
+%%    Lb = Integer
+%%  Given one of the possible representations for a BIT STRING
+%%  and the lower bound for the number of bits,
+%%  return a bitstring at least Lb bits long (padded with zeroes
+%%  if needed).
+
+to_bitstring({0,Bs}, Lb) when is_binary(Bs) ->
+    case bit_size(Bs) of
+	Sz when Sz < Lb ->
+	    <<Bs/bits,0:(Lb-Sz)>>;
+	_ ->
+	    Bs
+    end;
+to_bitstring({Unused,Bs0}, Lb) when is_binary(Bs0) ->
+    Sz = bit_size(Bs0) - Unused,
+    if
+	Sz < Lb ->
+	    <<Bs0:Sz/bits,0:(Lb-Sz)>>;
+	true ->
+	    <<Bs:Sz/bits,_/bits>> = Bs0,
+	    Bs
+    end;
+to_bitstring(Bs, Lb) when is_bitstring(Bs) ->
+    adjust_size(Bs, Lb);
+to_bitstring(Int, Lb) when is_integer(Int), Int >= 0 ->
+    L = int_to_bitlist(Int),
+    Bs = << <<B:1>> || B <- L >>,
+    adjust_size(Bs, Lb);
+to_bitstring(L, Lb) when is_list(L) ->
+    Bs = << <<B:1>> || B <- L >>,
+    adjust_size(Bs, Lb).
+
+%% to_named_bitstring(Val) -> BitString
+%%    Val = BitString | {Unused,Binary} | [OneOrZero] | Integer
+%%  Given one of the possible representations for a BIT STRING,
+%%  return a bitstring where any trailing zeroes have been stripped.
+
+to_named_bitstring(Val) ->
+    Bs = to_bitstring(Val),
+    bs_drop_trailing_zeroes(Bs).
+
+%% to_named_bitstring(Val, Lb) -> BitString
+%%    Val = BitString | {Unused,Binary} | [OneOrZero] | Integer
+%%    Lb = Integer
+%%  Given one of the possible representations for a BIT STRING
+%%  and the lower bound for the number of bits,
+%%  return a bitstring that is at least Lb bits long. There will
+%%  be zeroes at the right only if needed to reach the lower bound
+%%  for the number of bits.
+
+to_named_bitstring({0,Bs}, Lb) when is_binary(Bs) ->
+    adjust_trailing_zeroes(Bs, Lb);
+to_named_bitstring({Unused,Bs0}, Lb) when is_binary(Bs0) ->
+    Sz = bit_size(Bs0) - Unused,
+    <<Bs:Sz/bits,_/bits>> = Bs0,
+    adjust_trailing_zeroes(Bs, Lb);
+to_named_bitstring(Bs, Lb) when is_bitstring(Bs) ->
+    adjust_trailing_zeroes(Bs, Lb);
+to_named_bitstring(Val, Lb) ->
+    %% Obsolete representations: list or integer. Optimize
+    %% for correctness, not speed.
+    adjust_trailing_zeroes(to_bitstring(Val), Lb).
+
+is_default_bitstring(asn1_DEFAULT, _, _) ->
+    true;
+is_default_bitstring(Named, Named, _) ->
+    true;
+is_default_bitstring(Bs, _, Bs) ->
+    true;
+is_default_bitstring(Val, _, Def) when is_bitstring(Val) ->
+    Sz = bit_size(Def),
+    case Val of
+	<<Def:Sz/bitstring,T/bitstring>> ->
+	    NumZeroes = bit_size(T),
+	    case T of
+		<<0:NumZeroes>> -> true;
+		_ -> false
+	    end;
+	_ ->
+	    false
+    end.
+
+is_default_bitstring(asn1_DEFAULT, _, _, _, _) ->
+    true;
+is_default_bitstring({Unused,Bin}, V0, V1, V2, V3) when is_integer(Unused) ->
+    %% Convert compact bitstring to a bitstring.
+    Sz = bit_size(Bin) - Unused,
+    <<Bs:Sz/bitstring,_:Unused>> = Bin,
+    is_default_bitstring(Bs, V0, V1, V2, V3);
+is_default_bitstring(Named, Named, _, _, _) ->
+    true;
+is_default_bitstring(Bs, _, Bs, _, _) ->
+    true;
+is_default_bitstring(List, _, _, List, _) ->
+    true;
+is_default_bitstring(Int, _, _, _, Int) ->
+    true;
+is_default_bitstring(Val, _, Def, _, _) when is_bitstring(Val) ->
+    Sz = bit_size(Def),
+    case Val of
+	<<Def:Sz/bitstring,T/bitstring>> ->
+	    NumZeroes = bit_size(T),
+	    case T of
+		<<0:NumZeroes>> -> true;
+		_ -> false
+	    end;
+	_ ->
+	    false
+    end;
+is_default_bitstring(Val, _, _, List, _) when is_list(Val) ->
+    is_default_bitstring_list(List, Val);
+is_default_bitstring(_, _, _, _, _) -> false.
+
+extension_bitmap(Val, Pos, Limit) ->
+    extension_bitmap(Val, Pos, Limit, 0).
+
+open_type_to_binary({asn1_OPENTYPE,Bin}) when is_binary(Bin) ->
+    Bin.
+
+legacy_open_type_to_binary({asn1_OPENTYPE,Bin}) when is_binary(Bin) ->
+    Bin;
+legacy_open_type_to_binary(Bin) when is_binary(Bin) ->
+    Bin;
+legacy_open_type_to_binary(List) when is_list(List) ->
+    List.
+
 %%%
 %%% Internal functions.
 %%%
@@ -124,3 +376,170 @@ dec_subidentifiers([H|T], Av, Al) ->
     dec_subidentifiers(T, 0, [(Av bsl 7) bor H|Al]);
 dec_subidentifiers([], _Av, Al) ->
     lists:reverse(Al).
+
+enc_char(C0, Lb, Tab) ->
+    try	element(C0-Lb, Tab) of
+	ill ->
+	    illegal_char_error();
+	C ->
+	    C
+    catch
+	error:badarg ->
+	    illegal_char_error()
+    end.
+
+enc_char_cm(C0, Lb, Limit) ->
+    C = C0 - Lb,
+    if
+	0 =< C, C < Limit ->
+	    C;
+	true ->
+	    illegal_char_error()
+    end.
+
+illegal_char_error() ->
+    error({error,{asn1,"value forbidden by FROM constraint"}}).
+
+encode_fragmented_1(Bin, Unit, N) ->
+    SegSz = Unit * N * ?'16K',
+    case Bin of
+	<<B:SegSz/bitstring,T/bitstring>> ->
+	    [<<3:2,N:6>>,B|encode_fragmented_1(T, Unit, N)];
+	_ when N > 1 ->
+	    encode_fragmented_1(Bin, Unit, N-1);
+	_ ->
+	    case bit_size(Bin) div Unit of
+		Len when Len < 128 ->
+		    [Len,Bin];
+		Len when Len < 16384 ->
+		    [<<2:2,Len:14>>,Bin]
+	    end
+    end.
+
+%% E1 = 0|1|2 and (E2 < 40 when E1 = 0|1)
+e_object_identifier([E1,E2|Tail]) when E1 >= 0, E1 < 2, E2 < 40; E1 =:= 2 ->
+    Head = 40*E1 + E2,
+    e_object_elements([Head|Tail], []);
+e_object_identifier([_,_|_Tail]=Oid) ->
+    exit({error,{asn1,{'illegal_value',Oid}}}).
+
+e_object_elements([], Acc) ->
+    lists:reverse(Acc);
+e_object_elements([H|T], Acc) ->
+    e_object_elements(T, [e_object_element(H)|Acc]).
+
+e_object_element(Num) when Num < 128 ->
+    [Num];
+e_object_element(Num) ->
+    [e_o_e(Num bsr 7)|[Num band 2#1111111]].
+
+e_o_e(Num) when Num < 128 ->
+    Num bor 2#10000000;
+e_o_e(Num) ->
+    [e_o_e(Num bsr 7)|[(Num band 2#1111111) bor 2#10000000]].
+
+enint(-1, [B1|T]) when B1 > 127 ->
+    [B1|T];
+enint(N, Acc) ->
+    enint(N bsr 8, [N band 16#ff|Acc]).
+
+diff([H|T], Prev) ->
+    [H-Prev|diff(T, H)];
+diff([], _) -> [].
+
+diff([H|T], Prev, Last) ->
+    [{1,H-Prev}|diff(T, H, Last)];
+diff([], Prev, Last) when Last >= Prev ->
+    [{0,Last-Prev}];
+diff([], _, _) -> [].
+
+int_to_bitlist(0) -> [];
+int_to_bitlist(Int) -> [Int band 1|int_to_bitlist(Int bsr 1)].
+
+adjust_size(Bs, Lb) ->
+    case bit_size(Bs) of
+	Sz when Sz < Lb ->
+	    <<Bs:Sz/bits,0:(Lb-Sz)>>;
+	_ ->
+	    Bs
+    end.
+
+adjust_trailing_zeroes(Bs0, Lb) ->
+    case bit_size(Bs0) of
+	Sz when Sz < Lb ->
+	    %% Too short - pad with zeroes.
+	    <<Bs0:Sz/bits,0:(Lb-Sz)>>;
+	Lb ->
+	    %% Exactly the right size - nothing to do.
+	    Bs0;
+	_ ->
+	    %% Longer than the lower bound - drop trailing zeroes.
+	    <<_:Lb/bits,Tail/bits>> = Bs0,
+	    Sz = Lb + bit_size(bs_drop_trailing_zeroes(Tail)),
+	    <<Bs:Sz/bits,_/bits>> = Bs0,
+	    Bs
+    end.
+
+bs_drop_trailing_zeroes(Bs) ->
+    bs_drop_trailing_zeroes(Bs, bit_size(Bs)).
+
+bs_drop_trailing_zeroes(Bs, 0) ->
+    Bs;
+bs_drop_trailing_zeroes(Bs0, Sz0) when Sz0 < 8 ->
+    <<Byte:Sz0>> = Bs0,
+    Sz = Sz0 - ntz(Byte),
+    <<Bs:Sz/bits,_/bits>> = Bs0,
+    Bs;
+bs_drop_trailing_zeroes(Bs0, Sz0) ->
+    Sz1 = Sz0 - 8,
+    <<Bs1:Sz1/bits,Byte:8>> = Bs0,
+    case ntz(Byte) of
+	8 ->
+	    bs_drop_trailing_zeroes(Bs1, Sz1);
+	Ntz ->
+	    Sz = Sz0 - Ntz,
+	    <<Bs:Sz/bits,_:Ntz/bits>> = Bs0,
+	    Bs
+    end.
+
+%% ntz(Byte) -> Number of trailing zeroes.
+ntz(Byte) ->
+    %% The table was calculated like this:
+    %%   NTZ = fun (B, N, NTZ) when B band 1 =:= 0 -> NTZ(B bsr 1, N+1, NTZ); (_, N, _) -> N end.
+    %%   io:format("~w\n", [list_to_tuple([NTZ(B+256, 0, NTZ) || B <- lists:seq(0, 255)])]).
+    T = {8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
+	 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0},
+    element(Byte+1, T).
+
+is_default_bitstring_list([H|Def], [H|Val]) ->
+    is_default_bitstring_list(Def, Val);
+is_default_bitstring_list([], []) ->
+    true;
+is_default_bitstring_list([], [_|_]=Val) ->
+    lists:all(fun(0) -> true;
+		 (_) -> false
+	      end, Val);
+is_default_bitstring_list(_, _) -> false.
+
+extension_bitmap(_Val, Pos, Limit, Acc) when Pos >= Limit ->
+    Acc;
+extension_bitmap(Val, Pos, Limit, Acc) ->
+    Bit = case element(Pos, Val) of
+	      asn1_NOVALUE -> 0;
+	      _ -> 1
+	  end,
+    extension_bitmap(Val, Pos+1, Limit, (Acc bsl 1) bor Bit).
diff --git a/lib/asn1/src/asn1rtt_real_common.erl b/lib/asn1/src/asn1rtt_real_common.erl
index 22a1f4c4dd..3a79209015 100644
--- a/lib/asn1/src/asn1rtt_real_common.erl
+++ b/lib/asn1/src/asn1rtt_real_common.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -105,8 +106,7 @@ encode_real(_C, {Mantissa, Base, Exponent}) when Base =:= 2 ->
 		     true    -> list_to_binary(real_mininum_octets(-(Man))) % signbit keeps track of sign
 		  end,
     %%    ok = io:format("LenMask: ~w EOctets: ~w~nFirstOctet: ~w OctMantissa: ~w OctExpLen: ~w~n", [LenMask, EOctets, FirstOctet, OctMantissa, OctExpLen]),
-    Bin = <<FirstOctet/binary, EOctets/binary, OctMantissa/binary>>,
-    {Bin, size(Bin)};
+    <<FirstOctet/binary, EOctets/binary, OctMantissa/binary>>;
 encode_real(C, {Mantissa,Base,Exponent})
   when Base =:= 10, is_integer(Mantissa), is_integer(Exponent) ->
     %% always encode as NR3 due to DER on the format
@@ -176,8 +176,7 @@ encode_real_as_string(_C, Mantissa, Exponent)
 	end,
     ManBin = list_to_binary(TruncMant),
     NR3 = 3,
-    {<<NR3,ManBin/binary,$.,ExpBin/binary>>,
-     2 + byte_size(ManBin) + byte_size(ExpBin)}.
+    <<NR3,ManBin/binary,$.,ExpBin/binary>>.
 
 remove_trailing_zeros(IntStr) ->
     case lists:dropwhile(fun($0)-> true;
diff --git a/lib/asn1/src/asn1rtt_uper.erl b/lib/asn1/src/asn1rtt_uper.erl
index a5035c6660..0ab8fab141 100644
--- a/lib/asn1/src/asn1rtt_uper.erl
+++ b/lib/asn1/src/asn1rtt_uper.erl
@@ -1,113 +1,27 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
 %%
 -module(asn1rtt_uper).
 
--export([setext/1, fixoptionals/3,
-	 fixextensions/2,
-	 skipextensions/3]).
--export([set_choice/3, encode_integer/2, encode_integer/3]).
--export([encode_small_number/1, encode_constrained_number/2,
-	 encode_boolean/1,
-	 encode_length/1, encode_length/2,
-	 encode_bit_string/3]).
--export([encode_octet_string/1,encode_octet_string/2,
-	 encode_relative_oid/1,
-	 encode_object_identifier/1,
-	 complete/1, complete_NFP/1]).
-
- -export([encode_open_type/1]).
-
- -export([encode_UniversalString/3,
-	 encode_PrintableString/3,
-	 encode_GeneralString/2,
-	 encode_GraphicString/2,
-	 encode_TeletexString/2,
-	 encode_VideotexString/2,
-	 encode_VisibleString/3,
-	 encode_UTF8String/1,
-	 encode_BMPString/3,
-	 encode_IA5String/3,
-	 encode_NumericString/3,
-	 encode_ObjectDescriptor/2
-	]).
-
--define('16K',16384).
--define('32K',32768).
--define('64K',65536).
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% setext(true|false) ->  CompleteList
-%%
-
-setext(false) ->
-    <<0:1>>;
-setext(true) ->
-    <<1:1>>.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% This is the new fixoptionals/3 which is used by the new generates
-%%
-fixoptionals(OptList,OptLength,Val) when is_tuple(Val) ->
-    Bits = fixoptionals(OptList,Val,0),
-    {Val,<<Bits:OptLength>>};
-
-fixoptionals([],_Val,Acc) ->
-    %% Optbits
-    Acc;
-fixoptionals([{Pos,DefVal}|Ot],Val,Acc) ->
-    case element(Pos,Val) of
-	asn1_DEFAULT -> fixoptionals(Ot,Val,Acc bsl 1);
-	DefVal -> fixoptionals(Ot,Val,Acc bsl 1);
-	_ -> fixoptionals(Ot,Val,(Acc bsl 1) + 1)
-    end;
-fixoptionals([Pos|Ot],Val,Acc) ->
-    case element(Pos,Val) of
-	asn1_NOVALUE -> fixoptionals(Ot,Val,Acc bsl 1);
-	asn1_DEFAULT -> fixoptionals(Ot,Val,Acc bsl 1);
-	_ -> fixoptionals(Ot,Val,(Acc bsl 1) + 1)
-    end.
-
-
-fixextensions({ext,ExtPos,ExtNum},Val) ->
-    case fixextensions(ExtPos,ExtNum+ExtPos,Val,0) of
-	0 -> [];
-	ExtBits ->
-	    [encode_small_length(ExtNum),<<ExtBits:ExtNum>>]
-    end.
-
-fixextensions(Pos,MaxPos,_,Acc) when Pos >= MaxPos ->
-    Acc;
-fixextensions(Pos,ExtPos,Val,Acc) ->
-    Bit = case catch(element(Pos+1,Val)) of
-	      asn1_NOVALUE ->
-		  0;
-	      asn1_NOEXTVALUE ->
-		  0;
-	      {'EXIT',_} ->
-		  0;
-	      _ ->
-		  1
-	  end,
-    fixextensions(Pos+1,ExtPos,Val,(Acc bsl 1)+Bit).
+-export([skipextensions/3]).
+-export([complete/1, complete_NFP/1]).
 
 skipextensions(Bytes0, Nr, ExtensionBitstr) when is_bitstring(ExtensionBitstr) ->
     Prev = Nr - 1,
@@ -122,249 +36,6 @@ skipextensions(Bytes0, Nr, ExtensionBitstr) when is_bitstring(ExtensionBitstr) -
 	    Bytes0
     end.
 
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% set_choice(Alt,Choices,Altnum) -> ListofBitSettings
-%% Alt = atom()
-%% Altnum = integer() | {integer(),integer()}% number of alternatives
-%% Choices = [atom()] | {[atom()],[atom()]}
-%% When Choices is a tuple the first list is the Rootset and the
-%% second is the Extensions and then Altnum must also be a tuple with the
-%% lengths of the 2 lists
-%%
-set_choice(Alt, {L1,L2}, {Len1,_Len2}) ->
-    case set_choice_tag(Alt, L1) of
-	N when is_integer(N), Len1 > 1 ->
-	    [<<0:1>>, % the value is in the root set
-	     encode_integer([{'ValueRange',{0,Len1-1}}],N)];
-	N when is_integer(N) ->
-	    <<0:1>>; % no encoding if only 0 or 1 alternative
-	false ->
-	    [<<1:1>>, % extension value
-	     case set_choice_tag(Alt,L2) of
-		 N2 when is_integer(N2) ->
-		     encode_small_number(N2);
-		 false ->
-		     unknown_choice_alt
-	     end]
-    end;
-set_choice(Alt,L,Len) ->
-    case set_choice_tag(Alt,L) of
-	N when is_integer(N), Len > 1 ->
-	    encode_integer([{'ValueRange',{0,Len-1}}],N);
-	N when is_integer(N) ->
-	    []; % no encoding if only 0 or 1 alternative
-	false ->
-	    [unknown_choice_alt]
-    end.
-
-set_choice_tag(Alt,Choices) ->
-    set_choice_tag(Alt,Choices,0).
-
-set_choice_tag(Alt,[Alt|_Rest],Tag) ->
-    Tag;
-set_choice_tag(Alt,[_H|Rest],Tag) ->
-    set_choice_tag(Alt,Rest,Tag+1);
-set_choice_tag(_Alt,[],_Tag) ->
-    false.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_open_type(Constraint, Value) -> CompleteList
-%% Value = list of bytes of an already encoded value (the list must be flat)
-%%         | binary
-%% Contraint = not used in this version
-%%
-encode_open_type(Val) ->
-    [encode_length(byte_size(Val)),Val].
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_integer(Constraint,Value,NamedNumberList) -> CompleteList
-%% encode_integer(Constraint,Value) -> CompleteList
-%% encode_integer(Constraint,{Name,Value}) -> CompleteList
-%%
-%%
-encode_integer(C, V, NamedNumberList) when is_atom(V) ->
-    case lists:keyfind(V, 1, NamedNumberList) of
-	{_,NewV} ->
-	    encode_integer(C, NewV);
-	false ->
-	    exit({error,{asn1,{namednumber,V}}})
-    end;
-encode_integer(C, V, _NamedNumberList) when is_integer(V) ->
-    encode_integer(C, V).
-
-encode_integer([{Rc,_Ec}],Val) when is_tuple(Rc) ->
-    try
-	[<<0:1>>,encode_integer([Rc], Val)]
-    catch
-	_:{error,{asn1,_}} ->
-	    [<<1:1>>,encode_unconstrained_number(Val)]
-    end;
-encode_integer(C, Val) when is_list(C) ->
-    case get_constraint(C, 'SingleValue') of
-	no ->
-	    encode_integer1(C,Val);
-	V when is_integer(V), V =:= Val ->
-	    []; % a type restricted to a single value encodes to nothing
-	V when is_list(V) ->
-	    case lists:member(Val,V) of
-		true ->
-		    encode_integer1(C,Val);
-		_ ->
-		    exit({error,{asn1,{illegal_value,Val}}})
-	    end;
-	_ ->
-	    exit({error,{asn1,{illegal_value,Val}}})
-    end.
-
-encode_integer1(C, Val) ->
-    case VR = get_constraint(C, 'ValueRange') of
-	no ->
-	    encode_unconstrained_number(Val);
-	{Lb,'MAX'} when Lb =< Val ->
-	    encode_semi_constrained_number(Lb, Val);
-	%% positive with range
-	{Lb,Ub} when Val >= Lb, Ub >= Val ->
-	    encode_constrained_number(VR,Val);
-	_ ->
-	    exit({error,{asn1,{illegal_value,VR,Val}}})
-    end.
-
-%% X.691:10.6 Encoding of a normally small non-negative whole number
-%% Use this for encoding of CHOICE index if there is an extension marker in
-%% the CHOICE
-encode_small_number(Val) when Val < 64 ->
-    <<Val:7>>;
-encode_small_number(Val) ->
-    [<<1:1>>|encode_semi_constrained_number(0, Val)].
-
-%% X.691:10.7 Encoding of a semi-constrained whole number
-encode_semi_constrained_number(Lb, Val) ->
-    %% encoding in minimum number of octets preceeded by a length
-    Val2 = Val - Lb,
-    Bin = eint_bin_positive(Val2),
-    Size = byte_size(Bin),
-    if
-	Size < 128 ->
-	    [<<Size>>,Bin];
-	Size < 16384 ->
-	    [<<2:2,Size:14>>,Bin];
-	true ->
-	    [encode_length(Size),Bin]
-    end.
-
-encode_constrained_number({Lb,Ub}, Val) when Val >= Lb, Ub >= Val ->
-    Range = Ub - Lb + 1,
-    Val2 = Val - Lb,
-    NumBits = num_bits(Range),
-    <<Val2:NumBits>>;
-encode_constrained_number(Range,Val) ->
-    exit({error,{asn1,{integer_range,Range,value,Val}}}).
-
-%% X.691:10.8 Encoding of an unconstrained whole number
-
-encode_unconstrained_number(Val) when Val >= 0 ->
-    Oct = eint_bin_2Cs(Val),
-    Len = byte_size(Oct),
-    if
-	Len < 128 ->
-	    [<<Len>>,Oct]; % equiv with encode_length(undefined,Len) but faster
-	Len < 16384 ->
-	    [<<2:2,Len:14>>,Oct];
-	true ->
-	    [encode_length(Len),<<Len:16>>,Oct]
-    end;
-encode_unconstrained_number(Val) -> % negative
-    Oct = enint(Val,[]),
-    Len = byte_size(Oct),
-    if
-	Len < 128 ->
-	    [<<Len>>,Oct]; % equiv with encode_length(undefined,Len) but faster
-	Len < 16384 ->
-	    [<<2:2,Len:14>>,Oct];
-	true ->
-	    [encode_length(Len),Oct]
-    end.
-
-
-eint_bin_2Cs(Int) ->
-    case eint_bin_positive(Int) of
-	<<B,_/binary>> = Bin when B > 16#7f ->
-	    <<0,Bin/binary>>;
-	Bin -> Bin
-    end.
-
-%% returns the integer as a binary
-eint_bin_positive(Val) when Val < 16#100  ->
-    <<Val>>;
-eint_bin_positive(Val) when Val < 16#10000 ->
-    <<Val:16>>;
-eint_bin_positive(Val) when Val < 16#1000000 ->
-    <<Val:24>>;
-eint_bin_positive(Val) when Val < 16#100000000 ->
-    <<Val:32>>;
-eint_bin_positive(Val) ->
-    list_to_binary([eint_bin_positive2(Val bsr 32),<<Val:32>>]).
-
-eint_bin_positive2(Val) when Val < 16#100  ->
-    <<Val>>;
-eint_bin_positive2(Val) when Val < 16#10000 ->
-    <<Val:16>>;
-eint_bin_positive2(Val) when Val < 16#1000000 ->
-    <<Val:24>>;
-eint_bin_positive2(Val) when Val < 16#100000000 ->
-    <<Val:32>>;
-eint_bin_positive2(Val) ->
-    [eint_bin_positive2(Val bsr 32),<<Val:32>>].
-
-
-
-
-enint(-1, [B1|T]) when B1 > 127 ->
-    list_to_binary([B1|T]);
-enint(N, Acc) ->
-    enint(N bsr 8, [N band 16#ff|Acc]).
-
-
-%% X.691:10.9 Encoding of a length determinant
-%%encode_small_length(undefined,Len) -> % null means no UpperBound
-%%    encode_small_number(Len).
-
-%% X.691:10.9.3.5
-%% X.691:10.9.3.7
-encode_length(Len) -> % un-constrained
-    if
-	Len < 128 ->
-	    <<Len>>;
-	Len < 16384 ->
-	    <<2:2,Len:14>>;
-	true  -> % should be able to endode length >= 16384
-	    error({error,{asn1,{encode_length,{nyi,above_16k}}}})
-    end.
-
-encode_length({C,[]}, Len) ->
-    case C of
-	{Lb,Ub}=Vr when Lb =< Len, Len =< Ub ->
-	    [<<0:1>>|encode_constrained_number(Vr, Len)];
-	_ ->
-	    [<<1:1>>|encode_length(Len)]
-    end;
-encode_length(Len, Len) ->
-    [];
-encode_length(Vr, Len) ->
-    encode_constrained_number(Vr, Len).
-
-
-%% X.691 10.9.3.4 (only used for length of bitmap that prefixes extension
-%% additions in a sequence or set
-encode_small_length(Len) when Len =< 64 ->
-    <<(Len-1):7>>;
-encode_small_length(Len) ->
-    [<<1:1>>,encode_length(Len)].
-
-
 %% un-constrained
 decode_length(<<0:1,Oct:7,Rest/bitstring>>)  ->
     {Oct,Rest};
@@ -373,575 +44,20 @@ decode_length(<<2:2,Val:14,Rest/bitstring>>)  ->
 decode_length(<<3:2,_:14,_Rest/bitstring>>)  ->
     exit({error,{asn1,{decode_length,{nyi,above_16k}}}}).
 
-						% X.691:11
-encode_boolean(true) ->
-    <<1:1>>;
-encode_boolean(false) ->
-    <<0:1>>;
-encode_boolean(Val) ->
-    exit({error,{asn1,{encode_boolean,Val}}}).
-
-
-%%============================================================================
-%%============================================================================
-%% Bitstring value, ITU_T X.690 Chapter 8.5
-%%============================================================================
-%%============================================================================
-
-%%============================================================================
-%% encode bitstring value
-%%============================================================================
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% bitstring NamedBitList
-%% Val can be  of:
-%% - [identifiers] where only named identifers are set to one,
-%%   the Constraint must then have some information of the
-%%   bitlength.
-%% - [list of ones and zeroes] all bits
-%% - integer value representing the bitlist
-%% C is constraint Len, only valid when identifiers are present
-
-
-%% when the value is a list of {Unused,BinBits}, where
-%% Unused = integer(),
-%% BinBits = binary().
-
-encode_bit_string(C, Bits, NamedBitList) when is_bitstring(Bits) ->
-    PadLen = (8 - (bit_size(Bits) band 7)) band 7,
-    Compact = {PadLen,<<Bits/bitstring,0:PadLen>>},
-    encode_bit_string(C, Compact, NamedBitList);
-encode_bit_string(C, {Unused,BinBits}=Bin, NamedBitList)
-  when is_integer(Unused), is_binary(BinBits) ->
-    encode_bin_bit_string(C, Bin, NamedBitList);
-
-encode_bit_string(C, BitListVal, NamedBitList) ->
-    encode_bit_string1(C, BitListVal, NamedBitList).
-
-%% when the value is a list of named bits
-encode_bit_string1(C, [FirstVal|_RestVal]=LoNB, NamedBitList)
-  when is_atom(FirstVal) ->
-    ToSetPos = get_all_bitposes(LoNB, NamedBitList, []),
-    BitList = make_and_set_list(ToSetPos, 0),
-    encode_bit_string1(C, BitList, NamedBitList);
-encode_bit_string1(C, [{bit,_No}|_RestVal]=BL, NamedBitList) ->
-    ToSetPos = get_all_bitposes(BL, NamedBitList, []),
-    BitList = make_and_set_list(ToSetPos, 0),
-    encode_bit_string1(C, BitList, NamedBitList);
-%% when the value is a list of ones and zeroes
-encode_bit_string1(Int, BitListValue, _)
-  when is_list(BitListValue), is_integer(Int) ->
-    %% The type is constrained by a single value size constraint
-    bit_list2bitstr(Int, BitListValue);
-encode_bit_string1(no, BitListValue, [])
-  when is_list(BitListValue) ->
-    Len = length(BitListValue),
-    [encode_length(Len),bit_list2bitstr(Len,BitListValue)];
-encode_bit_string1(C, BitListValue,[])
-  when is_list(BitListValue) ->
-    Len = length(BitListValue),
-    [encode_length(C, Len),bit_list2bitstr(Len,BitListValue)];
-encode_bit_string1(no, BitListValue,_NamedBitList)
-  when is_list(BitListValue) ->
-    NewBitLVal = lists:reverse(lists:dropwhile(fun(0)->true;(1)->false end,
-					    lists:reverse(BitListValue))),
-    Len = length(NewBitLVal),
-    [encode_length(Len),bit_list2bitstr(Len,NewBitLVal)];
-encode_bit_string1(C, BitListValue, _NamedBitList)
-  when is_list(BitListValue) ->% C = {_,'MAX'}
-    NewBitStr = bitstr_trailing_zeros(BitListValue, C),
-    [encode_length(C, bit_size(NewBitStr)),NewBitStr];
-
-
-%% when the value is an integer
-encode_bit_string1(C, IntegerVal, NamedBitList) when is_integer(IntegerVal)->
-    BitList = int_to_bitlist(IntegerVal),
-    encode_bit_string1(C, BitList, NamedBitList).
-
-bit_list2bitstr(Len,BitListValue) ->
-    case length(BitListValue) of
-	Len ->
-	    << <<B:1>> || B <- BitListValue>>;
-	L when L > Len -> % truncate
-	    <<(<< <<B:1>> || B <- BitListValue>>):Len/bitstring>>;
-	L -> % Len > L -> pad
-	    <<(<< <<B:1>> || B <- BitListValue>>)/bitstring,0:(Len-L)>>
-	end.
-
-adjust_trailing_zeros(Len, Bin) when Len =:= bit_size(Bin) ->
-    Bin;
-adjust_trailing_zeros(Len, Bin) when Len > bit_size(Bin) ->
-    <<Bin/bitstring,0:(Len-bit_size(Bin))>>;
-adjust_trailing_zeros(Len,Bin) ->
-    <<Bin:Len/bitstring>>.
-
-bitstr_trailing_zeros(BitList, C) when is_integer(C) ->
-    bitstr_trailing_zeros1(BitList, C, C);
-bitstr_trailing_zeros(BitList, {Lb,Ub}) when is_integer(Lb) ->
-    bitstr_trailing_zeros1(BitList,Lb,Ub);
-bitstr_trailing_zeros(BitList, {{Lb,Ub},_}) when is_integer(Lb) ->
-    bitstr_trailing_zeros1(BitList, Lb, Ub);
-bitstr_trailing_zeros(BitList, _) ->
-    bit_list2bitstr(length(BitList), BitList).
-
-bitstr_trailing_zeros1(BitList, Lb, Ub) ->
-    case length(BitList) of
-	Lb -> bit_list2bitstr(Lb, BitList);
-	B when B < Lb -> bit_list2bitstr(Lb, BitList);
-	D -> F = fun(L,LB,LB,_,_)->bit_list2bitstr(LB,lists:reverse(L));
-		    ([0|R],L1,LB,UB,Fun)->Fun(R,L1-1,LB,UB,Fun);
-		    (L,L1,_,UB,_)when L1 =< UB ->
-			 bit_list2bitstr(L1,lists:reverse(L));
-		    (_,_L1,_,_,_) ->exit({error,{list_length_BIT_STRING,
-						 BitList}}) end,
-	     F(lists:reverse(BitList),D,Lb,Ub,F)
-    end.
-
-%% encode_bin_bit_string/3, when value is a tuple of Unused and BinBits.
-%% Unused = integer(),i.e. number unused bits in least sign. byte of
-%% BinBits = binary().
-encode_bin_bit_string(C, {_,BinBits}, _NamedBitList)
-  when is_integer(C), C =< 16 ->
-    adjust_trailing_zeros(C, BinBits);
-encode_bin_bit_string(C, {_Unused,BinBits}, _NamedBitList)
-  when is_integer(C) ->
-    adjust_trailing_zeros(C, BinBits);
-encode_bin_bit_string(C, {_,_}=UnusedAndBin, NamedBitList) ->
-    %% removes all trailing bits if NamedBitList is not empty
-    BitStr = remove_trailing_bin(NamedBitList, UnusedAndBin),
-    case C of
-	{Lb,Ub} when is_integer(Lb),is_integer(Ub) ->
-	    [encode_length({Lb,Ub},bit_size(BitStr)),BitStr];
-	no ->
-	    [encode_length(bit_size(BitStr)),BitStr];
-	Sc ->
-	    [encode_length(Sc,bit_size(BitStr)),BitStr]
-    end.
-
-
-remove_trailing_bin([], {Unused,Bin}) ->
-    BS = bit_size(Bin)-Unused,
-    <<BitStr:BS/bitstring,_:Unused>> = Bin,
-    BitStr;
-remove_trailing_bin(_NamedNumberList, {_Unused,<<>>}) ->
-    <<>>;
-remove_trailing_bin(NamedNumberList, {_Unused,Bin}) ->
-    Size = byte_size(Bin)-1,
-    <<Bfront:Size/binary, LastByte:8>> = Bin,
-
-    %% clear the Unused bits to be sure
-    Unused1 = trailingZeroesInNibble(LastByte band 15),
-    Unused2 =
-	case Unused1 of
-	    4 ->
-		4 + trailingZeroesInNibble(LastByte bsr 4);
-	    _ -> Unused1
-	end,
-    case Unused2 of
-	8 ->
-	    remove_trailing_bin(NamedNumberList,{0,Bfront});
-	_ ->
-	    BS = bit_size(Bin) - Unused2,
-	    <<BitStr:BS/bitstring,_:Unused2>> = Bin,
-	    BitStr
-    end.
-
-trailingZeroesInNibble(0) ->
-    4;
-trailingZeroesInNibble(1) ->
-    0;
-trailingZeroesInNibble(2) ->
-    1;
-trailingZeroesInNibble(3) ->
-    0;
-trailingZeroesInNibble(4) ->
-    2;
-trailingZeroesInNibble(5) ->
-    0;
-trailingZeroesInNibble(6) ->
-    1;
-trailingZeroesInNibble(7) ->
-    0;
-trailingZeroesInNibble(8) ->
-    3;
-trailingZeroesInNibble(9) ->
-    0;
-trailingZeroesInNibble(10) ->
-    1;
-trailingZeroesInNibble(11) ->
-    0;
-trailingZeroesInNibble(12) -> %#1100
-    2;
-trailingZeroesInNibble(13) ->
-    0;
-trailingZeroesInNibble(14) ->
-    1;
-trailingZeroesInNibble(15) ->
-    0.
-
-
-%%%%%%%%%%%%%%%
-%%
-
-int_to_bitlist(Int) when is_integer(Int), Int > 0 ->
-    [Int band 1 | int_to_bitlist(Int bsr 1)];
-int_to_bitlist(0) ->
-    [].
-
-
-%%%%%%%%%%%%%%%%%%
-%% get_all_bitposes([list of named bits to set], named_bit_db, []) ->
-%%   [sorted_list_of_bitpositions_to_set]
-
-get_all_bitposes([{bit,ValPos}|Rest], NamedBitList, Ack) ->
-    get_all_bitposes(Rest, NamedBitList, [ValPos | Ack ]);
-
-get_all_bitposes([Val | Rest], NamedBitList, Ack) ->
-    case lists:keyfind(Val, 1, NamedBitList) of
-	{_ValName, ValPos} ->
-	    get_all_bitposes(Rest, NamedBitList, [ValPos | Ack]);
-	false ->
-	    exit({error,{asn1, {bitstring_namedbit, Val}}})
-    end;
-get_all_bitposes([], _NamedBitList, Ack) ->
-    lists:sort(Ack).
-
-%%%%%%%%%%%%%%%%%%
-%% make_and_set_list([list of positions to set to 1])->
-%% returns list with all in SetPos set.
-%% in positioning in list the first element is 0, the second 1 etc.., but
-%%
-
-make_and_set_list([XPos|SetPos], XPos) ->
-    [1 | make_and_set_list(SetPos, XPos + 1)];
-make_and_set_list([Pos|SetPos], XPos) ->
-    [0 | make_and_set_list([Pos | SetPos], XPos + 1)];
-make_and_set_list([], _) ->
-    [].
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% X.691:16
-%% encode_octet_string(Val)
-%% encode_octet_string(Constraint, Val)
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-encode_octet_string(Val) ->
-    try
-	[encode_length(length(Val)),list_to_binary(Val)]
-    catch
-	error:{error,{asn1,{encode_length,_}}} ->
-	    encode_fragmented_octet_string(Val)
-    end.
-
-encode_octet_string(C, Val) ->
-    case C of
-	{_,_}=VR  ->
-	    try
-		[encode_length(VR, length(Val)),list_to_binary(Val)]
-	    catch
-		error:{error,{asn1,{encode_length,_}}} ->
-		    encode_fragmented_octet_string(Val)
-	    end;
-	Sv when is_integer(Sv), Sv =:= length(Val) -> % fixed length
-	    list_to_binary(Val)
-    end.
-
-
-encode_fragmented_octet_string(Val) ->
-    Bin = list_to_binary(Val),
-    efos_1(Bin).
-
-efos_1(<<B:16#10000/binary,T/binary>>) ->
-    [<<3:2,4:6>>,B|efos_1(T)];
-efos_1(<<B:16#C000/binary,T/binary>>) ->
-    [<<3:2,3:6>>,B|efos_1(T)];
-efos_1(<<B:16#8000/binary,T/binary>>) ->
-    [<<3:2,2:6>>,B|efos_1(T)];
-efos_1(<<B:16#4000/binary,T/binary>>) ->
-    [<<3:2,1:6>>,B|efos_1(T)];
-efos_1(<<B/bitstring>>) ->
-    Len = byte_size(B),
-    [encode_length(Len),B].
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% Restricted char string types
-%% (NumericString, PrintableString,VisibleString,IA5String,BMPString,UniversalString)
-%% X.691:26 and X.680:34-36
-%%encode_restricted_string('BMPString',Constraints,Extension,Val)
-
-
-encode_restricted_string(Val) when is_list(Val)->
-    [encode_length(length(Val)),list_to_binary(Val)].
-
-encode_known_multiplier_string(StringType, C, Pa, Val) ->
-    Result = chars_encode(Pa, StringType, Val),
-    case C of
-	Ub when is_integer(Ub) ->
-	    Result;
-	{_,_}=Range ->
-	    [encode_length(Range, length(Val)),Result];
-	no  ->
-	    [encode_length(length(Val)),Result]
-    end.
-
-encode_NumericString(C, Pa, Val) ->
-    encode_known_multiplier_string('NumericString', C, Pa, Val).
-
-encode_PrintableString(C, Pa, Val) ->
-    encode_known_multiplier_string('PrintableString', C, Pa, Val).
-
-encode_VisibleString(C, Pa, Val) -> % equivalent with ISO646String
-    encode_known_multiplier_string('VisibleString', C, Pa, Val).
-
-encode_IA5String(C, Pa, Val) ->
-    encode_known_multiplier_string('IA5String', C, Pa, Val).
-
-encode_BMPString(C, Pa, Val) ->
-    encode_known_multiplier_string('BMPString', C, Pa, Val).
-
-encode_UniversalString(C, Pa, Val) ->
-    encode_known_multiplier_string('UniversalString', C, Pa, Val).
-
-
-%% end of known-multiplier strings for which PER visible constraints are
-%% applied
-
-encode_GeneralString(_C,Val) ->
-    encode_restricted_string(Val).
-
-encode_GraphicString(_C,Val) ->
-    encode_restricted_string(Val).
-
-encode_ObjectDescriptor(_C,Val) ->
-    encode_restricted_string(Val).
-
-encode_TeletexString(_C,Val) -> % equivalent with T61String
-    encode_restricted_string(Val).
-
-encode_VideotexString(_C,Val) ->
-    encode_restricted_string(Val).
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% chars_encode(C,StringType,Value) -> ValueList
-%%
-%% encodes chars according to the per rules taking the constraint PermittedAlphabet
-%% into account.
-%% This function does only encode the value part and NOT the length
-
-chars_encode(Pa, StringType, Value) ->
-    case {StringType,Pa} of
-	{'UniversalString',{_,_Sv}} ->
-	    exit({error,{asn1,{'not implemented',"UniversalString with PermittedAlphabet constraint"}}});
-	{'BMPString',{_,_Sv}} ->
-	    exit({error,{asn1,{'not implemented',"BMPString with PermittedAlphabet constraint"}}});
-	_ ->
-	    {NumBits,CharOutTab} = {get_NumBits(Pa, StringType),
-				    get_CharOutTab(Pa, StringType)},
-	    chars_encode2(Value,NumBits,CharOutTab)
-    end.
-
-chars_encode2([H|T],NumBits,{Min,Max,notab}) when  H =< Max, H >= Min ->
-    [<<(H-Min):NumBits>>|chars_encode2(T,NumBits,{Min,Max,notab})];
-chars_encode2([H|T],NumBits,{Min,Max,Tab}) when H =< Max, H >= Min ->
-    Ch = exit_if_false(H,element(H-Min+1,Tab)),
-    [<<Ch:NumBits>>|chars_encode2(T,NumBits,{Min,Max,Tab})];
-chars_encode2([{A,B,C,D}|T],NumBits,{Min,Max,notab}) ->
-    %% no value range check here (ought to be, but very expensive)
-    Ch = ((((((A bsl 8)+B) bsl 8)+C) bsl 8)+D)-Min,
-    [<<Ch:NumBits>>|chars_encode2(T,NumBits,{Min,Max,notab})];
-chars_encode2([{A,B,C,D}|T],NumBits,{Min,Max,Tab}) ->
-    %% no value range check here (ought to be, but very expensive)
-    Ch = exit_if_false({A,B,C,D},element(((((((A bsl 8)+B) bsl 8)+C) bsl 8)+D)-Min,Tab)),
-    [<<Ch:NumBits>>|chars_encode2(T,NumBits,{Min,Max,notab})];
-chars_encode2([H|_T],_,{_,_,_}) ->
-    exit({error,{asn1,{illegal_char_value,H}}});
-chars_encode2([],_,_) ->
-    [].
-
-exit_if_false(V,false)->
-    exit({error,{asn1,{"illegal value according to Permitted alphabet constraint",V}}});
-exit_if_false(_,V) ->V.
-
-
-get_NumBits(Pa, StringType) ->
-    case Pa of
-	{'SingleValue',Sv} ->
-	    charbits(length(Sv));
-	no ->
-	    case StringType of
-		'IA5String' ->
-		    charbits(128); % 16#00..16#7F
-		'VisibleString' ->
-		    charbits(95); % 16#20..16#7E
-		'PrintableString' ->
-		    charbits(74); % [$\s,$',$(,$),$+,$,,$-,$.,$/,"0123456789",$:,$=,$?,$A..$Z,$a..$z
-		'NumericString' ->
-		    charbits(11); % $ ,"0123456789"
-		'UniversalString' ->
-		    32;
-		'BMPString' ->
-		    16
-	    end
-    end.
-
-get_CharOutTab(Pa, StringType) ->
-    case Pa of
-	{'SingleValue',Sv} ->
-	    get_CharTab2(Pa, StringType, hd(Sv), lists:max(Sv), Sv);
-	no ->
-	    case StringType of
-		'IA5String' ->
-		    {0,16#7F,notab};
-		'VisibleString' ->
-		    get_CharTab2(Pa, StringType, 16#20, 16#7F, notab);
-		'PrintableString' ->
-		    Chars = lists:sort(
-			      " '()+,-./0123456789:=?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"),
-		    get_CharTab2(Pa, StringType, hd(Chars),
-				 lists:max(Chars), Chars);
-		'NumericString' ->
-		    get_CharTab2(Pa, StringType, 16#20, $9, " 0123456789");
-		'UniversalString' ->
-		    {0,16#FFFFFFFF,notab};
-		'BMPString' ->
-		    {0,16#FFFF,notab}
-	    end
-    end.
-
-get_CharTab2(C,StringType,Min,Max,Chars) ->
-    BitValMax = (1 bsl get_NumBits(C,StringType))-1,
-    if
-	Max =< BitValMax ->
-	    {0,Max,notab};
-	true ->
-	    {Min,Max,create_char_tab(Min,Chars)}
-    end.
-
-create_char_tab(Min,L) ->
-    list_to_tuple(create_char_tab(Min,L,0)).
-create_char_tab(Min,[Min|T],V) ->
-    [V|create_char_tab(Min+1,T,V+1)];
-create_char_tab(_Min,[],_V) ->
-    [];
-create_char_tab(Min,L,V) ->
-    [false|create_char_tab(Min+1,L,V)].
-
-%% See Table 20.3 in Dubuisson
-charbits(NumOfChars) when NumOfChars =< 2 -> 1;
-charbits(NumOfChars) when NumOfChars =< 4 -> 2;
-charbits(NumOfChars) when NumOfChars =< 8 -> 3;
-charbits(NumOfChars) when NumOfChars =< 16 -> 4;
-charbits(NumOfChars) when NumOfChars =< 32 -> 5;
-charbits(NumOfChars) when NumOfChars =< 64 -> 6;
-charbits(NumOfChars) when NumOfChars =< 128 -> 7;
-charbits(NumOfChars) when NumOfChars =< 256 -> 8;
-charbits(NumOfChars) when NumOfChars =< 512 -> 9;
-charbits(NumOfChars) when NumOfChars =< 1024 -> 10;
-charbits(NumOfChars) when NumOfChars =< 2048 -> 11;
-charbits(NumOfChars) when NumOfChars =< 4096 -> 12;
-charbits(NumOfChars) when NumOfChars =< 8192 -> 13;
-charbits(NumOfChars) when NumOfChars =< 16384 -> 14;
-charbits(NumOfChars) when NumOfChars =< 32768 -> 15;
-charbits(NumOfChars) when NumOfChars =< 65536 -> 16;
-charbits(NumOfChars) when is_integer(NumOfChars) ->
-    16 + charbits1(NumOfChars bsr 16).
-
-charbits1(0) ->
-    0;
-charbits1(NumOfChars) ->
-    1 + charbits1(NumOfChars bsr 1).
-
-
-%% UTF8String
-encode_UTF8String(Val) when is_binary(Val) ->
-    [encode_length(byte_size(Val)),Val];
-encode_UTF8String(Val) ->
-    Bin = list_to_binary(Val),
-    encode_UTF8String(Bin).
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_object_identifier(Val) -> CompleteList
-%% encode_object_identifier({Name,Val}) -> CompleteList
-%% Val -> {Int1,Int2,...,IntN} % N >= 2
-%% Name -> atom()
-%% Int1 -> integer(0..2)
-%% Int2 -> integer(0..39) when Int1 (0..1) else integer()
-%% Int3-N -> integer()
-%% CompleteList -> [binary()|bitstring()|list()]
-%%
-encode_object_identifier(Val) ->
-    OctetList = e_object_identifier(Val),
-    Octets = list_to_binary(OctetList), % performs a flatten at the same time
-    [encode_length(byte_size(Octets)),Octets].
-
-%% This code is copied from asn1_encode.erl (BER) and corrected and modified
-
-e_object_identifier({'OBJECT IDENTIFIER',V}) ->
-    e_object_identifier(V);
-e_object_identifier(V) when is_tuple(V) ->
-    e_object_identifier(tuple_to_list(V));
-
-%% E1 = 0|1|2 and (E2 < 40 when E1 = 0|1)
-e_object_identifier([E1,E2|Tail]) when E1 >= 0, E1 < 2, E2 < 40 ; E1==2 ->
-    Head = 40*E1 + E2,  % weird
-    e_object_elements([Head|Tail],[]);
-e_object_identifier(Oid=[_,_|_Tail]) ->
-    exit({error,{asn1,{'illegal_value',Oid}}}).
-
-e_object_elements([],Acc) ->
-    lists:reverse(Acc);
-e_object_elements([H|T],Acc) ->
-    e_object_elements(T,[e_object_element(H)|Acc]).
-
-e_object_element(Num) when Num < 128 ->
-    [Num];
-e_object_element(Num) ->
-    [e_o_e(Num bsr 7)|[Num band 2#1111111]].
-e_o_e(Num) when Num < 128 ->
-    Num bor 2#10000000;
-e_o_e(Num) ->
-    [e_o_e(Num bsr 7)|[(Num band 2#1111111) bor 2#10000000]].
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% encode_relative_oid(Val) -> CompleteList
-%% encode_relative_oid({Name,Val}) -> CompleteList
-encode_relative_oid(Val) when is_tuple(Val) ->
-    encode_relative_oid(tuple_to_list(Val));
-encode_relative_oid(Val) when is_list(Val) ->
-    Octets = list_to_binary([e_object_element(X)||X <- Val]),
-    [encode_length(byte_size(Octets)),Octets].
-
-
-get_constraint([{Key,V}],Key) ->
-    V;
-get_constraint([],_Key) ->
-    no;
-get_constraint(C,Key) ->
-    case lists:keyfind(Key, 1, C) of
-	false ->
-	    no;
-	{_,V} ->
-	    V
-    end.
-
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% complete(InList) -> ByteList
 %% Takes a coded list with bits and bytes and converts it to a list of bytes
 %% Should be applied as the last step at encode of a complete ASN.1 type
 %%
 complete(InList) when is_list(InList) ->
-    case complete1(InList) of
+    case list_to_bitstring(InList) of
 	<<>> ->
 	    <<0>>;
 	Res ->
-	    case bit_size(Res) band 7 of
+	    Sz = bit_size(Res),
+	    case Sz band 7 of
 		0 -> Res;
-		Bits -> <<Res/bitstring,0:(8-Bits)>>
+		Bits -> <<Res:Sz/bitstring,0:(8-Bits)>>
 	end
     end;
 complete(Bin) when is_binary(Bin) ->
@@ -950,24 +66,12 @@ complete(Bin) when is_binary(Bin) ->
 	_ -> Bin
     end;
 complete(InList) when is_bitstring(InList) ->
-    PadLen = 8 - (bit_size(InList) band 7),
-    <<InList/bitstring,0:PadLen>>.
-
-complete1(L) when is_list(L) ->
-    list_to_bitstring(L).
+    Sz = bit_size(InList),
+    PadLen = 8 - (Sz band 7),
+    <<InList:Sz/bitstring,0:PadLen>>.
 
 %% Special version of complete that does not align the completed message.
 complete_NFP(InList) when is_list(InList) ->
     list_to_bitstring(InList);
 complete_NFP(InList) when is_bitstring(InList) ->
     InList.
-
-%% unaligned helpers
-
-%% 10.5.6 NOTE: If "range" satisfies the inequality 2^m < "range" =<
-%% 2^(m+1) then the number of bits = m + 1
-
-num_bits(N) -> num_bits(N, 1, 0).
-
-num_bits(N,T,B) when N =< T -> B;
-num_bits(N,T,B) -> num_bits(N, T bsl 1, B+1).
diff --git a/lib/asn1/src/notes_history.sgml b/lib/asn1/src/notes_history.sgml
index 107459b37d..9dccb5ff57 100644
--- a/lib/asn1/src/notes_history.sgml
+++ b/lib/asn1/src/notes_history.sgml
@@ -1,15 +1,16 @@
 <!doctype chapter PUBLIC "-//Stork//DTD chapter//EN">
 <!-- 
- ``The contents of this file are subject to the Erlang Public License,
- Version 1.1, (the "License"); you may not use this file except in
- compliance with the License. You should have received a copy of the
- Erlang Public License along with this software. If not, it can be
- retrieved via the world wide web at http://www.erlang.org/.
- 
- Software distributed under the License is distributed on an "AS IS"
- basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
- the License for the specific language governing rights and limitations
- under the License.
+ ``Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
  
  The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
diff --git a/lib/asn1/src/notes_latest.sgml b/lib/asn1/src/notes_latest.sgml
index 5a397ecbc2..641c41b843 100644
--- a/lib/asn1/src/notes_latest.sgml
+++ b/lib/asn1/src/notes_latest.sgml
@@ -1,15 +1,16 @@
 <!doctype chapter PUBLIC "-//Stork//DTD chapter//EN">
 <!-- 
- ``The contents of this file are subject to the Erlang Public License,
- Version 1.1, (the "License"); you may not use this file except in
- compliance with the License. You should have received a copy of the
- Erlang Public License along with this software. If not, it can be
- retrieved via the world wide web at http://www.erlang.org/.
- 
- Software distributed under the License is distributed on an "AS IS"
- basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
- the License for the specific language governing rights and limitations
- under the License.
+ ``Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
  
  The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
diff --git a/lib/asn1/src/prepare_templates.erl b/lib/asn1/src/prepare_templates.erl
index 83155b2e52..3f996a563f 100644
--- a/lib/asn1/src/prepare_templates.erl
+++ b/lib/asn1/src/prepare_templates.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
@@ -21,69 +22,77 @@
 -export([gen_asn1ct_rtt/1,gen_asn1ct_eval/1]).
 
 gen_asn1ct_rtt(Ms) ->
-    io:format("%% Generated by ~s. DO NOT EDIT THIS FILE.\n"
+    {ok,Fd} = file:open("asn1ct_rtt.erl", [write]),
+    io:format(Fd,
+	      "%% Generated by ~s. DO NOT EDIT THIS FILE.\n"
 	      "%%\n"
 	      "%% Input files:\n", [?MODULE]),
-    [io:put_chars(["%%  ",M,$\n]) || M <- Ms],
-    io:nl(),
-    io:put_chars("-module(asn1ct_rtt).\n"
+    [io:put_chars(Fd, ["%%  ",M,$\n]) || M <- Ms],
+    io:nl(Fd),
+    io:put_chars(Fd,
+		 "-module(asn1ct_rtt).\n"
 		 "-export([assert_defined/1,dependencies/1,code/0]).\n"
 		 "\n"),
     Forms = lists:sort(lists:append([abstract(M) || M <- Ms])),
     Exp = lists:sort(exports(Forms)),
-    defined(Exp),
-    io:nl(),
+    defined(Fd, Exp),
+    io:nl(Fd),
     Calls = calls(Forms),
     R = sofs:relation(Calls),
     Fam0 = sofs:relation_to_family(R),
     Fam = sofs:to_external(Fam0),
-    dependencies(Fam),
-    io:nl(),
+    dependencies(Fd, Fam),
+    io:nl(Fd),
     Funcs = [begin
 		 Bin = list_to_binary([$\n|erl_pp:function(Func)]),
 		 {{M,F,A},Bin}
 	     end || {M,{function,_,F,A,_}=Func} <- Forms],
-    io:format("code() ->\n~p.\n\n", [Funcs]),
+    io:format(Fd, "code() ->\n~p.\n\n", [Funcs]),
+    ok = file:close(Fd),
     halt(0).
 
 gen_asn1ct_eval([File]) ->
+    Output = filename:rootname(File, ".funcs") ++ ".erl",
+    {ok,Fd} = file:open(Output, [write]),
     {ok,Funcs} = file:consult(File),
     asn1ct_func:start_link(),
     [asn1ct_func:need(MFA) || MFA <- Funcs],
-    io:format("%% Generated by ~s. DO NOT EDIT THIS FILE.\n"
+    io:format(Fd,
+	      "%% Generated by ~s. DO NOT EDIT THIS FILE.\n"
 	      "%%\n"
 	      "%% Input file: ~s\n\n", [?MODULE,File]),
-    io:format("-module(~s).\n", [filename:rootname(File)]),
-    gen_asn1ct_eval_exp(Funcs),
-    asn1ct_func:generate(group_leader()),
+    io:format(Fd, "-module(~s).\n", [filename:rootname(File)]),
+    gen_asn1ct_eval_exp(Fd, Funcs),
+    asn1ct_func:generate(Fd),
+    ok = file:close(Fd),
     halt(0).
 
-gen_asn1ct_eval_exp(Funcs) ->
-    io:put_chars("-export(["),
-    gen_asn1ct_eval_exp_1(Funcs, ""),
-    io:put_chars("]).\n").
+gen_asn1ct_eval_exp(Fd, Funcs) ->
+    io:put_chars(Fd, "-export(["),
+    gen_asn1ct_eval_exp_1(Fd, Funcs, ""),
+    io:put_chars(Fd, "]).\n").
 
-gen_asn1ct_eval_exp_1([{_,F,A}|T], Sep) ->
-    io:put_chars(Sep),
-    io:format("~p/~p", [F,A]),
-    gen_asn1ct_eval_exp_1(T, ",\n");
-gen_asn1ct_eval_exp_1([], _) -> ok.
+gen_asn1ct_eval_exp_1(Fd, [{_,F,A}|T], Sep) ->
+    io:put_chars(Fd, Sep),
+    io:format(Fd, "~p/~p", [F,A]),
+    gen_asn1ct_eval_exp_1(Fd, T, ",\n");
+gen_asn1ct_eval_exp_1(_, [], _) -> ok.
 
-defined([H|T]) ->
-    io:format("assert_defined(~p) -> ok", [H]),
+defined(Fd, [H|T]) ->
+    io:format(Fd, "assert_defined(~p) -> ok", [H]),
     case T of
 	[] ->
-	    io:put_chars(".\n");
+	    io:put_chars(Fd, ".\n");
 	[_|_] ->
-	    io:put_chars(";\n"),
-	    defined(T)
+	    io:put_chars(Fd, ";\n"),
+	    defined(Fd, T)
     end.
 
-dependencies([{K,V}|T]) ->
-    io:format("dependencies(~p) ->\n~p;\n", [K,V]),
-    dependencies(T);
-dependencies([]) ->
-    io:put_chars("dependencies(_) -> [].\n").
+dependencies(Fd, [{K,V}|T]) ->
+    io:format(Fd, "dependencies(~p) ->\n~p;\n", [K,V]),
+    dependencies(Fd, T);
+dependencies(Fd, []) ->
+    io:put_chars(Fd, "dependencies(_) -> [].\n").
 
 abstract(File) ->
     {ok,{M0,[{abstract_code,Abstract}]}} =