Merge branch 'bjorn/asn1/dialyzer-warnings/OTP-11372' into maint

* bjorn/asn1/dialyzer-warnings/OTP-11372: (23 commits)
  BER: Eliminate dialyzer warnings for specialized decode functions
  BER: Eliminate dialyzer warning for encoding of BIT STRINGs
  BER: Optimize encoding of ENUMERATED
  BER: Remove a redundant clause in encoding of open types
  (U)PER: Fix decoding of named INTEGER
  (U)PER: Fix encoding of a semi-constrained, named INTEGER
  (U)PER: Optimize handling of named BIT STRING with a lower zero bound
  PER: Optimize encoding of character strings with simple ranges
  PER: Remove unnecessary clause for handling DEFAULT
  (U)PER: Suppress dialyzer warnings for complete/1
  Test suites: Add support for running Dialyzer on generated code
  Improve tests of DEFAULT values
  Correct OCTET STRING default when legacy_erlang_types is active
  Remove old DEFAULT-checking code made obsolete in the previous commit
  Rewrite the code for testing DEFAULT for DER
  Test DEFAULT more thoroughly
  Set.py: Correct illegal DEFAULT value
  BER: Optimize decoding of ENUMERATED
  BER: Suppress dialyzer warnings for encode_bit_string/4
  BER: Inline testing of constraints when decoding
  ...

12 files changed, 780 insertions, 879 deletions

diff --git a/lib/asn1/src/Makefile b/lib/asn1/src/Makefile
index 500f4a1358..6798da0072 100644
--- a/lib/asn1/src/Makefile
+++ b/lib/asn1/src/Makefile
@@ -52,6 +52,7 @@ CT_MODULES= \
 	asn1ct_pretty_format \
 	asn1ct_func \
 	asn1ct_gen \
+	asn1ct_gen_check \
 	asn1ct_gen_per \
 	asn1ct_name \
 	asn1ct_constructed_per \
diff --git a/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl b/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
index a38da8bcc2..5fadd0495a 100644
--- a/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
+++ b/lib/asn1/src/asn1ct_constructed_ber_bin_v2.erl
@@ -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}],
@@ -1029,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 -> {",
@@ -1063,10 +1055,9 @@ 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.
     
 
 gen_dec_line(Erules,TopType,Cname,CTags,Type,OptOrMand,DecObjInf)  ->
@@ -1210,11 +1201,11 @@ 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(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}} ->
 	    Term = asn1ct_gen:mk_var(asn1ct_name:curr(term)),
@@ -1226,8 +1217,9 @@ gen_dec_call(InnerType,Erules,TopType,Cname,Type,BytesVar,Tag,PrimOptOrMand,
 	    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,
@@ -1236,11 +1228,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,
@@ -1249,15 +1240,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 ed3f6f886e..a91404ed54 100644
--- a/lib/asn1/src/asn1ct_constructed_per.erl
+++ b/lib/asn1/src/asn1ct_constructed_per.erl
@@ -426,8 +426,7 @@ gen_dec_open_type(Erule, Val, {Xmod,Xtype}, LeadingAttr,
     emit([Term," = ",{asis,F},"(",TmpTerm,", ",Val,")"]).
 
 dec_objset_optional(N, {'DEFAULT',Val}) ->
-    dec_objset_optional_1(N, Val),
-    dec_objset_optional_1(N, asn1_DEFAULT);
+    dec_objset_optional_1(N, Val);
 dec_objset_optional(N, 'OPTIONAL') ->
     dec_objset_optional_1(N, asn1_NOVALUE);
 dec_objset_optional(_N, mandatory) -> ok.
diff --git a/lib/asn1/src/asn1ct_func.erl b/lib/asn1/src/asn1ct_func.erl
index 33f998722a..fb94f65b32 100644
--- a/lib/asn1/src/asn1ct_func.erl
+++ b/lib/asn1/src/asn1ct_func.erl
@@ -19,7 +19,8 @@
 %%
 
 -module(asn1ct_func).
--export([start_link/0,need/1,call/3,call_gen/3,call_gen/4,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() ->
@@ -63,6 +64,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).
 
@@ -103,7 +108,10 @@ handle_call({gen_func,Prefix,Key,GenFun}, _From, #st{gen=G0,gc=Gc0}=St) ->
 	    {reply,Name,St#st{gen=G,gc=Gc}};
 	{value,{Name,_}} ->
 	    {reply,Name,St}
-    end.
+    end;
+handle_call({is_used,MFA}, _From, #st{used=Used}=St) ->
+    {reply,gb_sets:is_member(MFA, Used),St}.
+
 
 terminate(_, _) ->
     ok.
diff --git a/lib/asn1/src/asn1ct_gen.erl b/lib/asn1/src/asn1ct_gen.erl
index 44b050e59d..450d309688 100644
--- a/lib/asn1/src/asn1ct_gen.erl
+++ b/lib/asn1/src/asn1ct_gen.erl
@@ -29,7 +29,6 @@
 	 list2rname/1,
 	 constructed_suffix/2,
 	 unify_if_string/1,
-	 gen_check_call/7,
 	 get_constraint/2,
 	 insert_once/2,
 	 ct_gen_module/1,
@@ -43,6 +42,8 @@
 -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
@@ -85,12 +86,18 @@ pgen_module(OutFile,Erules,Module,
 	  "%%%",nl,
 	  "%%% Run-time functions.",nl,
 	  "%%%",nl]),
+    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),
@@ -98,11 +105,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(_,_,[]) ->
@@ -178,23 +180,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),
-	    ok = 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);
@@ -542,8 +527,7 @@ 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}}}).
 
@@ -576,131 +560,6 @@ gen_types(Erules,Tname,Type) when is_record(Type,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(_,[],_)->
-    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_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 
 %% *************************************************
 %%**************************************************
@@ -790,8 +649,9 @@ gen_decode_constructed(Erules,Typename,InnerType,D) when is_record(D,typedef) ->
 
 
 pgen_exports(Erules,_Module,{Types,Values,_,_,Objects,ObjectSets}) ->
-    emit(["-export([encoding_rule/0,bit_string_format/0,"
+    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;
 	_ ->
@@ -1077,9 +937,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;
@@ -1093,13 +954,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]),
@@ -1465,171 +1326,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' ->
-	    case Type#type.def of
-		{_,[]} ->
-		    check_call(check_bitstring,
-			       [Default,Element]);
-		{_,[_|_]=NBL} ->
-		    check_call(check_named_bitstring,
-			       [Default,Element,{asis,NBL}])
-	    end;
-	'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
 	[] ->
@@ -1683,6 +1379,11 @@ conform_value(#type{def={'BIT STRING',[]}}, 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) ->
@@ -1901,11 +1602,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 bea0ec8968..e51b0898be 100644
--- a/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl
+++ b/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl
@@ -27,11 +27,12 @@
 -export([decode_class/1, decode_type/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 +66,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 +181,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;
@@ -208,11 +232,11 @@ gen_encode_prim(_Erules, #type{}=D, DoTag, Value) ->
 		  "end"]);
 	{'BIT STRING',[]} ->
 	    case asn1ct:use_legacy_types() of
-		false when BitStringConstraint =:= [] ->
+		false when MaxBitStrSize =:= none ->
 		    call(encode_unnamed_bit_string, [Value,DoTag]);
 		false ->
 		    call(encode_unnamed_bit_string,
-			 [{asis,BitStringConstraint},Value,DoTag]);
+			 [{asis,MaxBitStrSize},Value,DoTag]);
 		true ->
 		    call(encode_bit_string,
 			 [{asis,BitStringConstraint},Value,
@@ -220,12 +244,12 @@ gen_encode_prim(_Erules, #type{}=D, DoTag, Value) ->
 	    end;
 	{'BIT STRING',NamedNumberList} ->
 	    case asn1ct:use_legacy_types() of
-		false when BitStringConstraint =:= [] ->
+		false when MaxBitStrSize =:= none ->
 		    call(encode_named_bit_string,
 			 [Value,{asis,NamedNumberList},DoTag]);
 		false ->
 		    call(encode_named_bit_string,
-			 [{asis,BitStringConstraint},Value,
+			 [{asis,MaxBitStrSize},Value,
 			  {asis,NamedNumberList},DoTag]);
 		true ->
 		    call(encode_bit_string,
@@ -254,14 +278,20 @@ emit_enc_enumerated_cases(L, Tags) ->
     emit_enc_enumerated_cases(L, Tags, noext).
 
 emit_enc_enumerated_cases([{EnumName,EnumVal}|T], Tags, Ext) ->
+    Bytes = encode_pos_integer(EnumVal, []),
+    Len = length(Bytes),
     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_pos_integer(0, [B|_Acc] = L) when B < 128 ->
+    L;
+encode_pos_integer(N, Acc) ->
+    encode_pos_integer(N bsr 8, [N band 255|Acc]).
 
 %%===============================================================================
 %%===============================================================================
@@ -339,15 +369,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];
@@ -461,14 +487,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),
@@ -481,17 +505,10 @@ 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
 		      'NumericString'   -> restricted_string;
 		      'TeletexString'   -> restricted_string;
@@ -505,107 +522,77 @@ 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,
+    TagStr = case DoTag of
+		 {string,Tag1} -> Tag1;
+		 _ when is_list(DoTag) -> {asis,DoTag}
+	     end,
     case NewTypeName of
 	'BOOLEAN'->
-	    emit(["decode_boolean(",BytesVar,","]),
-	    need(decode_boolean, 2);
+	    call(decode_boolean, [BytesVar,TagStr]);
 	'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);
+	    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' ->
-	    ok;
-	{'BIT STRING',_NamedNumberList} ->
-	    ok;
+	    asn1ct_name:new(tmpbuf),
+	    emit(["begin",nl,
+		  {curr,tmpbuf}," = ",
+		  {call,ber,match_tags,[BytesVar,TagStr]},com,nl,
+		  {call,real_common,decode_real,[{curr,tmpbuf}]},nl,
+		  "end",nl]);
+	{'BIT STRING',NNL} ->
+	    gen_dec_bit_string(BytesVar, Constraint, NNL, TagStr);
 	'NULL' ->
-	    emit(["decode_null(",BytesVar,","]),
-	    need(decode_null, 2);
+	    call(decode_null, [BytesVar,TagStr]);
 	'OBJECT IDENTIFIER' ->
-	    emit(["decode_object_identifier(",BytesVar,","]),
-	    need(decode_object_identifier, 2);
+	    call(decode_object_identifier, [BytesVar,TagStr]);
 	'RELATIVE-OID' ->
-	    emit(["decode_relative_oid(",BytesVar,","]),
-	    need(decode_relative_oid, 2);
+	    call(decode_relative_oid, [BytesVar,TagStr]);
 	'OCTET STRING' ->
-	    F = case asn1ct:use_legacy_types() of
-		    false -> decode_octet_string;
-		    true -> decode_restricted_string
-		end,
-	    emit([{asis,F},"(",BytesVar,","]),
-	    case Constraint of
-		[] ->
-		    need(F, 2);
-		_ ->
-		    emit([{asis,Constraint},","]),
-		    need(F, 3)
-	    end;
+	    check_constraint(decode_octet_string, [BytesVar,TagStr],
+			     Constraint, {erlang,byte_size}, identity);
 	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;
+	    check_constraint(decode_restricted_string, [BytesVar,TagStr],
+			     Constraint,
+			     {erlang,byte_size},
+			     fun(Val) ->
+				     emit("binary_to_list("),
+				     Val(),
+				     emit(")")
+			     end);
 	'UniversalString' ->
-	    emit(["decode_universal_string",AsBin,"(",
-		  BytesVar,",",{asis,Constraint},","]),
-	    need(decode_universal_string, 3);
+	    check_constraint(decode_universal_string, [BytesVar,TagStr],
+			     Constraint, {erlang,length}, identity);
 	'UTF8String' ->
-	    emit(["decode_UTF8_string",AsBin,"(",
-		  BytesVar,","]),
-	    need(decode_UTF8_string, 2);
+	    call(decode_UTF8_string, [BytesVar,TagStr]);
 	'BMPString' ->
-	    emit(["decode_BMP_string",AsBin,"(",
-		  BytesVar,",",{asis,Constraint},","]),
-	    need(decode_BMP_string, 3);
+	    check_constraint(decode_BMP_string, [BytesVar,TagStr],
+			     Constraint, {erlang,length}, identity);
 	'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);
-	'REAL' ->
-	    asn1ct_name:new(tmpbuf),
-	    emit(["begin",nl,
-		  {curr,tmpbuf}," = ",
-		  {call,ber,match_tags,[BytesVar,TagStr]},com,nl,
-		  {call,real_common,decode_real,[{curr,tmpbuf}]},nl,
-		  "end",nl]);
-	_ ->
-	    emit([TagStr,")"])
+	    call(decode_open_type_as_binary, [BytesVar,TagStr])
     end.
 
 %% Simplify an integer constraint so that we can efficiently test it.
@@ -621,7 +608,7 @@ int_constr(C) ->
 	[{'ValueRange',{_,_}=Range}] ->
 	    Range;
 	[{'SingleValue',Sv}] ->
-	    {Sv,Sv};
+	    Sv;
 	[] ->
 	    []
     end.
@@ -632,16 +619,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
 %% ------------------------------------------------
@@ -986,9 +1065,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,
@@ -1016,8 +1094,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]),
@@ -1386,7 +1463,7 @@ emit_dec_open_type(I) ->
 	end,
     emit(S).
 
-emit_inner_of_decfun(#typedef{name={ExtName,Name},typespec=Type},Prop,
+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],
@@ -1394,8 +1471,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_",
@@ -1412,7 +1488,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],
@@ -1423,8 +1499,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,")"]);
@@ -1561,6 +1636,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..d80a02dfbf
--- /dev/null
+++ b/lib/asn1/src/asn1ct_gen_check.erl
@@ -0,0 +1,271 @@
+%% vim: tabstop=8:shiftwidth=4
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2014. 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_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 519ce9f054..39cc0536f8 100644
--- a/lib/asn1/src/asn1ct_gen_per.erl
+++ b/lib/asn1/src/asn1ct_gen_per.erl
@@ -32,6 +32,7 @@
 -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 +41,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).
diff --git a/lib/asn1/src/asn1ct_imm.erl b/lib/asn1/src/asn1ct_imm.erl
index fde39c674e..bdd14871d1 100644
--- a/lib/asn1/src/asn1ct_imm.erl
+++ b/lib/asn1/src/asn1ct_imm.erl
@@ -82,15 +82,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),
@@ -124,7 +117,7 @@ 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),
@@ -175,6 +168,8 @@ per_enc_bit_string(Val0, NNL0, Constraint0, Aligned) ->
     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,
@@ -203,6 +198,7 @@ per_enc_legacy_bit_string(Val0, NNL0, Constraint0, Aligned) ->
     Constraint = effective_constraint(bitstring, Constraint0),
     ExtraArgs = case constr_min_size(Constraint) of
 		    no -> [];
+		    0 -> [];
 		    Lb -> [Lb]
 		end,
     B ++ [{'try',
@@ -265,10 +261,6 @@ per_enc_k_m_string(Val0, StringType, Constraint, Aligned) ->
     SzConstraint = effective_constraint(bitstring, Constraint),
     Unit = string_num_bits(StringType, Constraint, Aligned),
     Chars0 = char_tab(Constraint, StringType, Unit),
-    Args = case enc_char_tab(Chars0) of
-	       notab -> [Val,Unit];
-	       Chars -> [Val,Unit,Chars]
-	   end,
     Enc = case Unit of
 	      16 ->
 		  {call,per_common,encode_chars_16bit,[Val],Bin};
@@ -277,7 +269,15 @@ per_enc_k_m_string(Val0, StringType, Constraint, Aligned) ->
 	      8 ->
 		  {call,erlang,list_to_binary,[Val],Bin};
 	      _ ->
-		  {call,per_common,encode_chars,Args,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 ->
@@ -581,14 +581,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) ->
@@ -1289,6 +1317,8 @@ 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.
@@ -1303,9 +1333,15 @@ prepend_to_cond_1([Check|T], Code) ->
 enc_char_tab(notab) ->
     notab;
 enc_char_tab(Tab0) ->
-    Tab = tuple_to_list(Tab0),
-    First = hd(Tab),
-    {First-1,list_to_tuple(enc_char_tab_1(Tab, First, 0))}.
+    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)];
diff --git a/lib/asn1/src/asn1rtt_ber.erl b/lib/asn1/src/asn1rtt_ber.erl
index 4bd814769f..c4cd872368 100644
--- a/lib/asn1/src/asn1rtt_ber.erl
+++ b/lib/asn1/src/asn1rtt_ber.erl
@@ -26,25 +26,24 @@
 	 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_octet_string/2,decode_octet_string/3,
-	 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]).
@@ -591,8 +590,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)).
 
@@ -697,41 +694,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,_} ->
@@ -740,49 +710,6 @@ number2name(Int, NamedNumberList) ->
 	    Int
     end.
 
-
-%%============================================================================
-%% Enumerated value, ITU_T X.690 Chapter 8.4
-
-%% encode enumerated 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.
-
-decode_enumerated1(Val, NamedNumberList) ->
-    %% it must be a named integer
-    case lists:keyfind(Val, 2, NamedNumberList) of
-	{NamedVal, _} ->
-	    NamedVal;
-	_ ->
-	    {asn1_enum,Val}
-    end.
-
 %%============================================================================
 %% Bitstring value, ITU_T X.690 Chapter 8.6
 %%
@@ -794,45 +721,46 @@ encode_unnamed_bit_string(Bits, TagIn) ->
     Bin = <<Unused,Bits/bitstring,0:Unused>>,
     encode_tags(TagIn, Bin, byte_size(Bin)).
 
-encode_unnamed_bit_string(C, Bits, TagIn) ->
+encode_unnamed_bit_string(MaxBits, Bits, TagIn) ->
     NumBits = bit_size(Bits),
     Unused = (8 - (NumBits band 7)) band 7,
     Bin = <<Unused,Bits/bitstring,0:Unused>>,
-    case C of
-	{_Min,Max} ->
-	    if
-		NumBits > Max ->
-		    exit({error,{asn1,
-				 {bitstring_length,
-				  {{was,NumBits},{maximum,Max}}}}});
-		true ->
-		    ok
-	    end;
-	Size ->
-	    if NumBits =< Size ->
-		    ok;
-	       true ->
-		    exit({error,{asn1,
-				 {bitstring_length,
-				  {{was,NumBits},{should_be,Size}}}}})
-	    end
-    end,
-    encode_tags(TagIn, Bin, byte_size(Bin)).
+    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) ->
-    encode_bit_string_named([], Bits, NamedBitList, TagIn);
+    do_encode_named_bit_string(Bits, NamedBitList, TagIn);
 encode_named_bit_string([{bit,_}|_]=Bits, NamedBitList, TagIn) ->
-    encode_bit_string_named([], Bits, NamedBitList, TagIn);
+    do_encode_named_bit_string(Bits, NamedBitList, 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) ->
-    encode_bit_string_named(C, Bits, NamedBitList, TagIn);
+    do_encode_named_bit_string(C, Bits, NamedBitList, TagIn);
 encode_named_bit_string(C, [{bit,_}|_]=Bits, NamedBitList, TagIn) ->
-    encode_bit_string_named(C, Bits, NamedBitList, TagIn);
+    do_encode_named_bit_string(C, Bits, NamedBitList, 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
 %%
@@ -932,15 +860,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).
@@ -1098,33 +1025,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) ->
@@ -1147,6 +1064,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
 %%----------------------------------------
@@ -1310,31 +1230,12 @@ decode_octet_string(Tlv, TagsIn) ->
     Bin = match_and_collect(Tlv, TagsIn),
     binary:copy(Bin).
 
-decode_octet_string(Tlv, Range, TagsIn) ->
-    Bin0 = match_and_collect(Tlv, TagsIn),
-    Bin = binary:copy(Bin0),
-    check_restricted_string(Bin, byte_size(Bin), Range).
-
 %%============================================================================
 %% decode Numeric Printable Teletex Videotex Visible IA5 Graphic General strings
 %%============================================================================
 
 decode_restricted_string(Tlv, TagsIn) ->
-    Bin = match_and_collect(Tlv, TagsIn),
-    binary_to_list(Bin).
-
-decode_restricted_string(Tlv, Range, TagsIn) ->
-    Bin = match_and_collect(Tlv, TagsIn),
-    check_restricted_string(binary_to_list(Bin), byte_size(Bin), Range).
-
-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}}}).
+    match_and_collect(Tlv, TagsIn).
 
 %%============================================================================
 %% encode Universal string
@@ -1360,10 +1261,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, []).
@@ -1423,10 +1323,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 be4f9c8bff..0083867a10 100644
--- a/lib/asn1/src/asn1rtt_check.erl
+++ b/lib/asn1/src/asn1rtt_check.erl
@@ -18,43 +18,41 @@
 %%
 -module(asn1rtt_check).
 
--export([check_bool/2,
+-export([check_fail/1,
 	 check_int/3,
-	 check_bitstring/2,check_named_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})
+	    throw(false)
     end;
-check_int(DefaultValue, _Value, _) ->
-    throw({error,DefaultValue}).
+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(_, asn1_DEFAULT) ->
-    true;
 check_bitstring(DefVal, {Unused,Binary}) ->
     %% User value in compact format.
     Sz = bit_size(Binary) - Unused,
@@ -62,7 +60,7 @@ check_bitstring(DefVal, {Unused,Binary}) ->
     check_bitstring(DefVal, Val);
 check_bitstring(DefVal, Val) when is_bitstring(Val) ->
     case Val =:= DefVal of
-	false -> throw(error);
+	false -> throw(false);
 	true -> true
     end;
 check_bitstring(Def, Val) when is_list(Val) ->
@@ -75,178 +73,95 @@ check_bitstring_list(<<H:1,T1/bitstring>>, [H|T2]) ->
 check_bitstring_list(<<>>, []) ->
     true;
 check_bitstring_list(_, _) ->
-    throw(error).
+    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(error).
-
-check_named_bitstring(_, asn1_DEFAULT, _) ->
-    true;
-check_named_bitstring(V, V, _) ->
-    true;
-%% Default value and user value as lists of ones and zeros
-check_named_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL=[_H|_T]) when is_integer(H1), is_integer(H2) ->
-    L2new = remove_trailing_zeros(L2),
-    check_named_bitstring(L1, L2new, NBL);
-%% Default value as a list of 1 and 0 and user value as a list of atoms
-check_named_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL) when is_integer(H1), is_atom(H2) ->
-    L3 = bit_list_to_nbl(L1, NBL, 0, []),
-    check_named_bitstring(L3, L2, NBL);
-%% Both default value and user value as a list of atoms
-check_named_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})
-    end;
-%% Default value as a list of atoms and user value as a list of 1 and 0
-check_named_bitstring(L1=[H1|_T1], L2=[H2|_T2], NBL) when is_atom(H1), is_integer(H2) ->
-    L3 = bit_list_to_nbl(L2, NBL, 0, []),
-    check_named_bitstring(L1, L3, NBL);
-%% User value in compact format
-check_named_bitstring(DefVal,CBS={_,_}, NBL) ->
-    NewVal = cbs_to_bit_list(CBS),
-    check_named_bitstring(DefVal, NewVal, NBL);
-%% User value as a binary
-check_named_bitstring(DefVal, CBS, NBL) when is_binary(CBS) ->
-    NewVal = cbs_to_bit_list({0,CBS}),
-    check_named_bitstring(DefVal, NewVal, NBL);
-%% User value as a bitstring
-check_named_bitstring(DefVal, CBS, NBL) when is_bitstring(CBS) ->
-    BitSize = bit_size(CBS),
-    Unused = 8 - (BitSize band 7),
-    NewVal = cbs_to_bit_list({Unused,<<CBS:BitSize/bits,0:Unused>>}),
-    check_named_bitstring(DefVal, NewVal, NBL);
-check_named_bitstring(DV, V, _) ->
-    throw({error,DV,V}).
-
-int_to_bit_list(0, Acc, 0) ->
-    Acc;
-int_to_bit_list(Int, Acc, Len) when Len > 0 ->
-    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]);
+    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) ->
+check_named_bitstring(Bs, _, Bs, _) ->
     true;
-check_null('NULL', 'NULL') ->
-    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;
@@ -262,21 +177,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]) ->
@@ -295,7 +195,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_per_common.erl b/lib/asn1/src/asn1rtt_per_common.erl
index 71fec411a0..0290c75a28 100644
--- a/lib/asn1/src/asn1rtt_per_common.erl
+++ b/lib/asn1/src/asn1rtt_per_common.erl
@@ -30,6 +30,7 @@
 	 decode_big_chars/2,
 	 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,
@@ -108,6 +109,9 @@ encode_chars(Val, NumBits) ->
 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];
@@ -383,6 +387,15 @@ enc_char(C0, Lb, Tab) ->
 	    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"}}).