Rewrite the code for testing DEFAULT for DER

The old code for testing DEFAULT values is messy, inefficient, and
causes dialyzer warnings.

4 files changed, 385 insertions, 214 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 3271f7958a..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)  ->
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/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.