Merge branch 'maint'

* maint:
  Teach the ASN.1 compiler the no_ok_wrapper option
  Optimize the generated decode/2 function

5 files changed, 165 insertions, 102 deletions

diff --git a/lib/asn1/doc/src/asn1ct.xml b/lib/asn1/doc/src/asn1ct.xml
index 6b6f46d39f..ada2aace87 100644
--- a/lib/asn1/doc/src/asn1ct.xml
+++ b/lib/asn1/doc/src/asn1ct.xml
@@ -66,7 +66,7 @@
         <v>Option = ber | per | uper | der | compact_bit_string |
 	legacy_bit_string |
 	noobj | {n2n, EnumTypeName} |{outdir, Dir} | {i, IncludeDir} |
-	asn1config | undec_rest |
+	asn1config | undec_rest | no_ok_wrapper |
 	{macro_name_prefix, Prefix} | {record_name_prefix, Prefix} | verbose | warnings_as_errors</v>
         <v>OldOption = ber | per</v> 
         <v>Reason = term()</v>
@@ -238,6 +238,13 @@ File3.asn        </pre>
               list or a binary. Earlier versions of the compiler ignored
               those following bytes.</p>
           </item>
+	  <tag><c>no_ok_wrapper</c></tag>
+	  <item>
+	    <p>If this option is given, the generated <c>encode/2</c>
+	    and <c>decode/2</c> functions will not wrap a successful
+	    return value in an <c>{ok,...}</c> tuple. If any error
+	    occurs, there will be an exception.</p>
+	  </item>
           <tag><c>{macro_name_prefix, Prefix}</c></tag>
           <item>
               <p>All macro names generated by the compiler are prefixed with
diff --git a/lib/asn1/src/asn1ct_gen.erl b/lib/asn1/src/asn1ct_gen.erl
index c526c28b70..3452d29085 100644
--- a/lib/asn1/src/asn1ct_gen.erl
+++ b/lib/asn1/src/asn1ct_gen.erl
@@ -909,49 +909,45 @@ pgen_dispatcher(Erules,_Module,{[],_Values,_,_,_Objects,_ObjectSets}) ->
 pgen_dispatcher(Erules,_Module,{Types,_Values,_,_,_Objects,_ObjectSets}) ->
     emit(["-export([encode/2,decode/2]).",nl,nl]),
     gen_info_functions(Erules),
-    NoFinalPadding = lists:member(no_final_padding,get(encoding_options)),
-    {Call,BytesAsBinary} =
-	case Erules of
-	    per ->
-		asn1ct_func:need({Erules,complete,1}),
-		{["complete(encode_disp(Type, Data))"],"Bytes"};
-	    ber ->
-		{"encode_disp(Type,Data)","iolist_to_binary(Bytes)"};
-	    uper when NoFinalPadding == true ->
-		asn1ct_func:need({Erules,complete_NFP,1}),
-		{"complete_NFP(encode_disp(Type, Data))","Bytes"};
-	    uper ->
-		asn1ct_func:need({Erules,complete,1}),
-		{["complete(encode_disp(Type, Data))"],"Bytes"}
-	end,
-    emit(["encode(Type,Data) ->",nl,
-	  "try ",Call," of",nl,
-	  case erule(Erules) of
-	      ber ->
-		  ["  {Bytes,_Len} ->",nl,
-		   "    {ok,",BytesAsBinary,"}",nl];
-	      per ->
-		  ["  Bytes ->",nl,
-		   "    {ok,",BytesAsBinary,"}",nl]
-	  end,
-	  "  catch",nl,
-	  "    Class:Exception when Class =:= error; Class =:= exit ->",nl,
-          "      case Exception of",nl,
-	  "        {error,Reason}=Error ->",nl,
-	  "          Error;",nl,
-	  "        Reason ->",nl,
-	  "         {error,{asn1,Reason}}",nl,
-	  "      end",nl,
-	  "end.",nl,nl]),
-
-    Return_rest = lists:member(undec_rest,get(encoding_options)),
+
+    Options = get(encoding_options),
+    NoFinalPadding = lists:member(no_final_padding, Options),
+    NoOkWrapper = proplists:get_bool(no_ok_wrapper, Options),
+
+    Call = case Erules of
+	       per ->
+		   asn1ct_func:need({Erules,complete,1}),
+		   "complete(encode_disp(Type, Data))";
+	       ber ->
+		   "iolist_to_binary(element(1, encode_disp(Type, Data)))";
+	       uper when NoFinalPadding == true ->
+		   asn1ct_func:need({Erules,complete_NFP,1}),
+		   "complete_NFP(encode_disp(Type, Data))";
+	       uper ->
+		   asn1ct_func:need({Erules,complete,1}),
+		   "complete(encode_disp(Type, Data))"
+	   end,
+
+    emit(["encode(Type, Data) ->",nl]),
+    case NoOkWrapper of
+	true ->
+	    emit(["  ",Call,"."]);
+	false ->
+	    emit(["try ",Call," of",nl,
+		  "  Bytes ->",nl,
+		  "    {ok,Bytes}",nl,
+		  try_catch()])
+    end,
+    emit([nl,nl]),
+
+    Return_rest = proplists:get_bool(undec_rest, Options),
     Data = case {Erules,Return_rest} of
 	       {ber,true} -> "Data0";
 	       _ -> "Data"
 	   end,
 
     emit(["decode(Type,",Data,") ->",nl]),
-    DecAnonymous =
+    DecWrap =
 	case {Erules,Return_rest} of
 	    {ber,false} ->
 		asn1ct_func:need({ber,ber_decode_nif,1}),
@@ -963,49 +959,26 @@ pgen_dispatcher(Erules,_Module,{Types,_Values,_,_,_Objects,_ObjectSets}) ->
 	    _ ->
 		"Data"
 	end,
-    DecWrap = case Erules of
-		  ber ->
-		      DecAnonymous;
-		  _ -> "Data"
-	      end,
-	    
-    emit(["case catch decode_disp(Type,",DecWrap,") of",nl,
-	  "  {'EXIT',{error,Reason}} ->",nl,
-	  "    {error,Reason};",nl,
-	  "  {'EXIT',Reason} ->",nl,
-	  "    {error,{asn1,Reason}};",nl]),
-    case {Erules,Return_rest} of 
-	{ber,false} ->
-	    emit(["  Result ->",nl,
-		  "    {ok,Result}",nl]);
-	{ber,true} ->
-	    emit(["  Result ->",nl,
-		  "    {ok,Result,Rest}",nl]);
-	{_,false} ->
-	    emit(["  {X,_Rest} ->",nl,
-		  "    {ok,X};",nl,
-		  "  {X,_Rest,_Len} ->",nl,
-		  "    {ok,X}",nl]);
-	{per,true} ->
-	    emit(["  {X,{_,Rest}} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,{_,Rest},_Len} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,Rest} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,Rest,_Len} ->",nl,
-		  "    {ok,X,Rest}",nl]);
-	{uper,true} ->
-	    emit(["  {X,{_,Rest}} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,{_,Rest},_Len} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,Rest} ->",nl,
-		  "    {ok,X,Rest};",nl,
-		  "  {X,Rest,_Len} ->",nl,
-		  "    {ok,X,Rest}",nl])
+    emit([case NoOkWrapper of
+	      false -> "try";
+	      true -> "case"
+	  end, " decode_disp(Type, ",DecWrap,") of",nl]),
+    case erule(Erules) of
+	ber ->
+	    emit(["  Result ->",nl]);
+	per ->
+	    emit(["  {Result,Rest} ->",nl])
+    end,
+    case Return_rest of
+	false -> result_line(NoOkWrapper, ["Result"]);
+	true ->  result_line(NoOkWrapper, ["Result","Rest"])
+    end,
+    case NoOkWrapper of
+	false ->
+	    emit([nl,try_catch(),nl,nl]);
+	true ->
+	    emit([nl,"end.",nl,nl])
     end,
-    emit(["end.",nl,nl]),
 
     gen_decode_partial_incomplete(Erules),
 
@@ -1018,8 +991,30 @@ pgen_dispatcher(Erules,_Module,{Types,_Values,_,_,_Objects,_ObjectSets}) ->
 	    gen_dispatcher(Types,"encode_disp","enc_",""),
 	    gen_dispatcher(Types,"decode_disp","dec_","")
     end,
-    emit([nl]),
-    emit({nl,nl}).
+    emit([nl,nl]).
+
+result_line(NoOkWrapper, Items) ->
+    S = ["    "|case NoOkWrapper of
+		    false -> result_line_1(["ok"|Items]);
+		    true -> result_line_1(Items)
+		end],
+    emit(lists:flatten(S)).
+
+result_line_1([SingleItem]) ->
+    SingleItem;
+result_line_1(Items) ->
+    ["{",string:join(Items, ","),"}"].
+
+try_catch() ->
+    ["  catch",nl,
+     "    Class:Exception when Class =:= error; Class =:= exit ->",nl,
+     "      case Exception of",nl,
+     "        {error,Reason}=Error ->",nl,
+     "          Error;",nl,
+     "        Reason ->",nl,
+     "         {error,{asn1,Reason}}",nl,
+     "      end",nl,
+     "end."].
 
 gen_info_functions(Erules) ->
     emit(["encoding_rule() -> ",
diff --git a/lib/asn1/test/asn1_SUITE.erl b/lib/asn1/test/asn1_SUITE.erl
index a558a2941f..61b360ddf2 100644
--- a/lib/asn1/test/asn1_SUITE.erl
+++ b/lib/asn1/test/asn1_SUITE.erl
@@ -297,7 +297,15 @@ cover(_) ->
 
 testPrim(Config) -> test(Config, fun testPrim/3).
 testPrim(Config, Rule, Opts) ->
-    asn1_test_lib:compile_all(["Prim", "Real"], Config, [Rule|Opts]),
+    Files = ["Prim","Real"],
+    asn1_test_lib:compile_all(Files, Config, [Rule|Opts]),
+    do_test_prim(Rule, false),
+    asn1_test_lib:compile_all(Files, Config, [no_ok_wrapper,Rule|Opts]),
+    do_test_prim(Rule, true).
+
+do_test_prim(Rule, NoOkWrapper) ->
+    io:format("No ok wrapper: ~p\n", [NoOkWrapper]),
+    put(no_ok_wrapper, NoOkWrapper),
     testPrim:bool(Rule),
     testPrim:int(Rule),
     testPrim:enum(Rule),
@@ -925,10 +933,14 @@ testNortel(Config, Rule, Opts) ->
 
 test_undecoded_rest(Config) -> test(Config, fun test_undecoded_rest/3).
 test_undecoded_rest(Config, Rule, Opts) ->
+    do_test_undecoded_rest(Config, Rule, Opts),
+    do_test_undecoded_rest(Config, Rule, [no_ok_wrapper|Opts]),
+    do_test_undecoded_rest(Config, Rule, [undec_rest|Opts]),
+    do_test_undecoded_rest(Config, Rule, [no_ok_wrapper,undec_rest|Opts]).
+
+do_test_undecoded_rest(Config, Rule, Opts) ->
     asn1_test_lib:compile("P-Record", Config, [Rule|Opts]),
-    ok = test_undecoded_rest:test([], Config),
-    asn1_test_lib:compile("P-Record", Config, [Rule,undec_rest|Opts]),
-    test_undecoded_rest:test(undec_rest, Config).
+    test_undecoded_rest:test(Opts, Config).
 
 testTcapsystem(Config) ->
     test(Config, fun testTcapsystem/3).
diff --git a/lib/asn1/test/testPrim.erl b/lib/asn1/test/testPrim.erl
index 5e3890b175..e07379e634 100644
--- a/lib/asn1/test/testPrim.erl
+++ b/lib/asn1/test/testPrim.erl
@@ -36,8 +36,7 @@ bool(Rules) ->
     case Rules of
 	ber ->
 	    [begin
-		 {error,{asn1,{encode_boolean,517}}} =
-		     (catch 'Prim':encode(T, 517))
+		 {error,{asn1,{encode_boolean,517}}} = enc_error(T, 517)
 	     end || T <- Types],
 	    ok;
 	_ ->
@@ -90,12 +89,12 @@ enum(Rules) ->
 
     roundtrip('Enum', monday),
     roundtrip('Enum', thursday),
-    {error,{asn1,{_,4}}} = (catch 'Prim':encode('Enum', 4)),
+    {error,{asn1,{_,4}}} = enc_error('Enum', 4),
 
     case Rules of
 	Per when Per =:= per; Per =:= uper ->
-	    {ok,<<0>>} = 'Prim':encode('SingleEnumVal', true),
-	    {ok,<<0>>} = 'Prim':encode('SingleEnumValExt', true);
+	    <<0>> = roundtrip('SingleEnumVal', true),
+	    <<0>> = roundtrip('SingleEnumValExt', true);
 	ber ->
 	    ok
     end,
@@ -132,10 +131,32 @@ null(_Rules) ->
     ok.
 
 roundtrip(T, V) ->
-    asn1_test_lib:roundtrip_enc('Prim', T, V, V).
+    roundtrip(T, V, V).
 
 roundtrip(Type, Value, ExpectedValue) ->
-    asn1_test_lib:roundtrip_enc('Prim', Type, Value, ExpectedValue).
+    case get(no_ok_wrapper) of
+	false ->
+	    asn1_test_lib:roundtrip_enc('Prim', Type, Value, ExpectedValue);
+	true ->
+	    M = 'Prim',
+	    Enc = M:encode(Type, Value),
+	    ExpectedValue = M:decode(Type, Enc),
+	    Enc
+    end.
+
+enc_error(T, V) ->
+    case get(no_ok_wrapper) of
+	false ->
+	    'Prim':encode(T, V);
+	true ->
+	    try 'Prim':encode(T, V) of
+		_ ->
+		    ?t:fail()
+	    catch
+		_:Reason ->
+		    Reason
+	    end
+    end.
 
 real(_Rules) ->
     %%==========================================================
@@ -177,4 +198,11 @@ real_roundtrip(T, V) ->
     real_roundtrip(T, V, V).
 
 real_roundtrip(Type, Value, ExpectedValue) ->
-    asn1_test_lib:roundtrip('Real', Type, Value, ExpectedValue).
+    case get(no_ok_wrapper) of
+	false ->
+	    asn1_test_lib:roundtrip('Real', Type, Value, ExpectedValue);
+	true ->
+	    M = 'Real',
+	    ExpectedValue = M:decode(Type, M:encode(Type, Value)),
+	    ok
+    end.
diff --git a/lib/asn1/test/test_undecoded_rest.erl b/lib/asn1/test/test_undecoded_rest.erl
index fe04178bb1..91e614d38a 100644
--- a/lib/asn1/test/test_undecoded_rest.erl
+++ b/lib/asn1/test/test_undecoded_rest.erl
@@ -26,21 +26,42 @@
 
 %% testing OTP-5104
 
-test(Opt, Config) ->
+test(Opts, Config) ->
     {ok,Msg} = asn1ct:value('P-Record', 'PersonnelRecord',
 			    [{i,?config(case_dir, Config)}]),
-    {ok,Bytes0} = 'P-Record':encode('PersonnelRecord', Msg),
+    Bytes0 = encode(Opts, 'PersonnelRecord', Msg),
     Bytes1 = iolist_to_binary([Bytes0, <<55,55,55>>]),
-    case Opt of
-        undec_rest ->
-            {ok,Msg,R} = 'P-Record':decode('PersonnelRecord', Bytes1),
+    case proplists:get_bool(undec_rest, Opts) of
+	true ->
+            {Msg,R} = decode(Opts, 'PersonnelRecord', Bytes1),
             case R of
-                <<55,55,55>> -> ok;
+                <<55,55,55>> ->
+		    ok;
                 BStr when is_bitstring(BStr) ->
                     PadLen = (8 - (bit_size(BStr) rem 8)) rem 8,
                     <<0,55,55,55>> = <<0:PadLen, BStr/bitstring>>
             end;
-        _ ->
-            {ok,Msg} = 'P-Record':decode('PersonnelRecord', Bytes1)
+        false ->
+            Msg = decode(Opts, 'PersonnelRecord', Bytes1)
     end,
     ok.
+
+encode(Opts, T, V) ->
+    M = 'P-Record',
+    case proplists:get_bool(no_ok_wrapper, Opts) of
+	false ->
+	    {ok,Enc} = M:encode(T, V),
+	    Enc;
+	true ->
+	    Enc = M:encode(T, V),
+	    true = is_binary(Enc),
+	    Enc
+    end.
+
+decode(Opts, T, E) ->
+    M = 'P-Record',
+    case {proplists:get_bool(no_ok_wrapper, Opts),M:decode(T, E)} of
+	{false,{ok,Val}} -> Val;
+	{false,{ok,Val,Rest}} -> {Val,Rest};
+	{true,Result} -> Result
+    end.