Merge branch 'kenneth/asn1/ExtensionAdditionGroup/OTP-8598' of ../kenneth_otp into HEAD

* 'kenneth/asn1/ExtensionAdditionGroup/OTP-8598' of ../kenneth_otp:
  Update of vsn.mk, relnotes and appup for patch in R13B04 track
  Add support for Extension addition group

1 files changed, 225 insertions, 83 deletions

diff --git a/lib/asn1/src/asn1ct_constructed_per.erl b/lib/asn1/src/asn1ct_constructed_per.erl
index 2a1c0ebc6b..df430c4f88 100644
--- a/lib/asn1/src/asn1ct_constructed_per.erl
+++ b/lib/asn1/src/asn1ct_constructed_per.erl
@@ -1,19 +1,19 @@
 %%
 %% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
-%% 
+%%
+%% Copyright Ericsson AB 1997-2010. 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%
 %%
 %%
@@ -46,13 +46,24 @@ gen_encode_constructed(Erule,Typename,D) when is_record(D,type) ->
     asn1ct_name:start(),
     asn1ct_name:new(term),
     asn1ct_name:new(bytes),
-    {CompList,TableConsInfo} = 
+    {ExtAddGroup,TmpCompList,TableConsInfo} =
 	case D#type.def of
-	    #'SEQUENCE'{tablecinf=TCI,components=CL} ->
-		{CL,TCI};
+	    #'SEQUENCE'{tablecinf=TCI,components=CL,extaddgroup=ExtAddGroup0} ->
+		{ExtAddGroup0,CL,TCI};
 	    #'SET'{tablecinf=TCI,components=CL} ->
-		{CL,TCI}
+		{undefined,CL,TCI}
 	end,
+
+    CompList = case ExtAddGroup of
+		   undefined ->
+		       TmpCompList;
+		   _ when is_integer(ExtAddGroup) ->
+		       %% This is a fake SEQUENCE representing an ExtensionAdditionGroup
+		       %% Reset the textual order so we get the right
+		       %% index of the components
+		       [Comp#'ComponentType'{textual_order=undefined}||
+			   Comp<-TmpCompList]
+	       end,
     case Typename of
 	['EXTERNAL'] ->
 	    emit({{var,asn1ct_name:next(val)},
@@ -78,7 +89,7 @@ gen_encode_constructed(Erule,Typename,D) when is_record(D,type) ->
 		  ",",{var,asn1ct_name:curr(val)},"),",nl})
     end,
     asn1ct_name:new(val),
-    Ext = extensible(CompList),
+    Ext = extensible_enc(CompList),
     case Ext of
 	{ext,_,NumExt} when NumExt > 0 ->
 	    emit(["Extensions = ?RT_PER:fixextensions(",{asis,Ext},
@@ -188,9 +199,10 @@ gen_decode_constructed(Erules,Typename,D) when is_record(D,type) ->
 	    #'SEQUENCE'{tablecinf=TCI,components=CL} ->
 		{add_textual_order(CL),TCI};
 	    #'SET'{tablecinf=TCI,components=CL} ->
-		{add_textual_order(CL),TCI}
+%%		{add_textual_order(CL),TCI}
+		{CL,TCI} % the textual order is already taken care of
 	end,
-    Ext = extensible(CompList),
+    Ext = extensible_dec(CompList),
     MaybeComma1 = case Ext of
 		      {ext,_Pos,_NumExt} -> 
 			  gen_dec_extension_value("Bytes"),
@@ -243,8 +255,9 @@ gen_decode_constructed(Erules,Typename,D) when is_record(D,type) ->
 			{false,false,false}
 		end
 	end,
+    NewCompList = wrap_compList(CompList),
     {AccTerm,AccBytes} =
-	gen_dec_components_call(Erules,Typename,CompList,MaybeComma2,DecObjInf,Ext,length(Optionals)),
+	gen_dec_components_call(Erules,Typename,NewCompList,MaybeComma2,DecObjInf,Ext,length(Optionals)),
     case asn1ct_name:all(term) of
 	[] -> emit(MaybeComma2); % no components at all
 	_ -> emit({com,nl})
@@ -284,7 +297,10 @@ gen_decode_constructed(Erules,Typename,D) when is_record(D,type) ->
 	    emit("   {ASN11994Format,");
 	_ ->
 	    emit(["{{'",RecordName,"'"]),
-	    mkvlist(textual_order(CompList,asn1ct_name:all(term))),
+	    %% CompList is used here because we don't want
+	    %% ExtensionAdditionGroups to be wrapped in SEQUENCES when
+	    %% we are ordering the fields according to textual order
+	    mkvlist(textual_order(to_encoding_order(CompList),asn1ct_name:all(term))),
 	    emit("},")
     end,
     emit({{var,asn1ct_name:curr(bytes)},"}"}),
@@ -293,17 +309,12 @@ gen_decode_constructed(Erules,Typename,D) when is_record(D,type) ->
 textual_order([#'ComponentType'{textual_order=undefined}|_],TermList) ->
     TermList;
 textual_order(CompList,TermList) when is_list(CompList) ->
-    TermTuple = list_to_tuple(TermList), %% ['Term1','Term2',...'TermN']
-    %% OrderList is ordered by canonical order of tags
-    TmpTuple = TermTuple,
-    OrderList = [Ix||#'ComponentType'{textual_order=Ix} <- CompList], 
-    Fun = fun(X,{Tpl,Ix}) ->
-		  
-		  {setelement(X,Tpl,element(Ix,TermTuple)),Ix+1}
-	  end,
-    {Ret,_} = lists:foldl(Fun,{TmpTuple,1},OrderList),
-%%    io:format("TermTuple: ~p~nOrderList: ~p~nRet: ~p~n",[TermTuple,OrderList,tuple_to_list(Ret)]),
-    tuple_to_list(Ret);
+     OrderList = [Ix||#'ComponentType'{textual_order=Ix} <- CompList],
+    [Term||{_,Term}<-
+	       lists:sort(lists:zip(OrderList,
+				    lists:sublist(TermList,length(OrderList))))];
+	       %% sublist is just because Termlist can sometimes be longer than
+	       %% OrderList, which it really shouldn't
 textual_order({Root,Ext},TermList) ->
     textual_order(Root ++ Ext,TermList);
 textual_order({Root1,Ext,Root2},TermList) ->
@@ -379,7 +390,7 @@ emit_opt_or_mand_check(Val,Term) ->
 gen_encode_choice(Erule,Typename,D) when is_record(D,type) ->
     {'CHOICE',CompList} = D#type.def,
     emit({"[",nl}),
-    Ext = extensible(CompList),
+    Ext = extensible_enc(CompList),
     gen_enc_choice(Erule,Typename,CompList,Ext),
     emit({nl,"].",nl}).
 
@@ -388,7 +399,7 @@ gen_decode_choice(Erules,Typename,D) when is_record(D,type) ->
     asn1ct_name:clear(),
     asn1ct_name:new(bytes),
     {'CHOICE',CompList} = D#type.def,
-    Ext = extensible(CompList),
+    Ext = extensible_enc(CompList),
     gen_dec_choice(Erules,Typename,CompList,Ext),
     emit({".",nl}).
 
@@ -558,12 +569,32 @@ mkvlist2([H|T]) ->
 mkvlist2([]) ->
     true.
 
-extensible(CompList) when is_list(CompList) ->
+
+extensible_dec(CompList) when is_list(CompList) ->
+    noext;
+extensible_dec({RootList,ExtList}) ->
+    {ext,length(RootList)+1,ext_length(ExtList)};
+extensible_dec({Rl1,Ext,Rl2}) ->
+     {ext,length(Rl1)+length(Rl2)+1,ext_length(Ext)}.
+
+extensible_enc(CompList) when is_list(CompList) ->
     noext;
-extensible({RootList,ExtList}) ->
-    {ext,length(RootList)+1,length(ExtList)};
-extensible({Rl1,Ext,_Rl2}) ->
-     {ext,length(Rl1)+1,length(Ext)}.
+extensible_enc({RootList,ExtList}) ->
+    {ext,length(RootList)+1,ext_length(ExtList)};
+extensible_enc({Rl1,Ext,_Rl2}) ->
+     {ext,length(Rl1)+1,ext_length(Ext)}.
+
+ext_length(ExtList) -> ext_length(ExtList,normal,0).
+ext_length([{'ExtensionAdditionGroup',_Num}|T],_,Acc)->
+    ext_length(T,group,Acc);
+ext_length(['ExtensionAdditionGroupEnd'|T],group,Acc) ->
+    ext_length(T,normal,Acc+1);
+ext_length([#'ComponentType'{}|T],State=group,Acc) ->
+    ext_length(T,State,Acc);
+ext_length([#'ComponentType'{}|T],State=normal,Acc) ->
+    ext_length(T,State,Acc+1);
+ext_length([],_,Acc) ->
+    Acc.
 
 gen_dec_extension_value(_) ->
     emit({"{Ext,",{next,bytes},"} = ?RT_PER:getext(",{curr,bytes},")"}),
@@ -574,7 +605,11 @@ gen_dec_extension_value(_) ->
 %% there are optional components, start with 2 because first element
 %% is the record name
 
-optionals({L1,_Ext,L2}) -> optionals(L1++L2,[],2); 
+optionals({L1,Ext,L2}) ->
+    Opt1 = optionals(L1,[],2),
+    ExtComps = length([C||C = #'ComponentType'{}<-Ext]),
+    Opt2 = optionals(L2,[],2+length(L1)+ExtComps),
+    Opt1 ++ Opt2;
 optionals({L,_Ext}) -> optionals(L,[],2); 
 optionals(L) -> optionals(L,[],2).
 
@@ -617,6 +652,13 @@ get_optionality_pos(TextPos,OptTable) ->
 	    no_num
     end.
 
+to_encoding_order(Cs) when is_list(Cs) ->
+    Cs;
+to_encoding_order(Cs = {_Root,_Ext}) ->
+    Cs;
+to_encoding_order({R1,Ext,R2}) ->
+    {R1++R2,Ext}.
+
 add_textual_order(Cs) when is_list(Cs) ->
     {NewCs,_} = add_textual_order1(Cs,1),
     NewCs;
@@ -629,26 +671,20 @@ add_textual_order({R1,Ext,R2}) ->
     {NewExt,Num2} = add_textual_order1(Ext,Num1),
     {NewR2,_} = add_textual_order1(R2,Num2),
     {NewR1,NewExt,NewR2}.
-add_textual_order1(Cs=[#'ComponentType'{textual_order=Int}|_],I)
-  when is_integer(Int) ->
-    {Cs,I};
+%%add_textual_order1(Cs=[#'ComponentType'{textual_order=Int}|_],I)
+%%  when is_integer(Int) ->
+%%    {Cs,I};
 add_textual_order1(Cs,NumIn) ->
-    lists:mapfoldl(fun(C,Num) ->
+    lists:mapfoldl(fun(C=#'ComponentType'{},Num) ->
 			   {C#'ComponentType'{textual_order=Num},
-			    Num+1}
+			    Num+1};
+		      (OtherMarker,Num) ->
+			   {OtherMarker,Num}
 		   end,
 		   NumIn,Cs).
 
 gen_enc_components_call(Erule,TopType,{Root1,ExtList,Root2},MaybeComma,DynamicEnc,Ext) ->
-    Rpos = gen_enc_components_call1(Erule,TopType,Root1,1,MaybeComma,DynamicEnc,noext),
-    case Ext of
-	{ext,_,ExtNum} when ExtNum > 0 ->
-	    emit([nl,
-		  ",Extensions",nl]);
-	_ -> true
-    end,
-    Rpos2 = gen_enc_components_call1(Erule,TopType,ExtList,Rpos,MaybeComma,DynamicEnc,Ext),
-    gen_enc_components_call1(Erule,TopType,Root2,Rpos2,MaybeComma,DynamicEnc,noext);
+    gen_enc_components_call(Erule,TopType,{Root1++Root2,ExtList},MaybeComma,DynamicEnc,Ext);
 gen_enc_components_call(Erule,TopType,{CompList,ExtList},MaybeComma,DynamicEnc,Ext) ->
     %% The type has extensionmarker
     Rpos = gen_enc_components_call1(Erule,TopType,CompList,1,MaybeComma,DynamicEnc,noext),
@@ -659,7 +695,8 @@ gen_enc_components_call(Erule,TopType,{CompList,ExtList},MaybeComma,DynamicEnc,E
 	_ -> true
     end,
     %handle extensions
-    gen_enc_components_call1(Erule,TopType,ExtList,Rpos,MaybeComma,DynamicEnc,Ext);
+    NewExtList = wrap_extensionAdditionGroups(ExtList),
+    gen_enc_components_call1(Erule,TopType,NewExtList,Rpos,MaybeComma,DynamicEnc,Ext);
 gen_enc_components_call(Erule,TopType, CompList, MaybeComma, DynamicEnc, Ext) ->
     %% The type has no extensionmarker
     gen_enc_components_call1(Erule,TopType,CompList,1,MaybeComma,DynamicEnc,Ext).
@@ -719,6 +756,26 @@ gen_enc_component_default(Erule,TopType,Cname,Type,Pos,DynamicEnc,Ext,DefaultVal
     NextElement = asn1ct_gen:mk_var(asn1ct_name:curr(tmpval)),
     gen_enc_line(Erule,TopType,Cname,Type,NextElement, Pos,DynamicEnc,Ext),
     emit({nl,"end"}).
+
+gen_enc_component_optional(Erule,TopType,Cname,
+			   Type=#type{def=#'SEQUENCE'{
+					extaddgroup=Number,
+					components=ExtGroupCompList}},
+			   Pos,DynamicEnc,Ext) when is_integer(Number) ->
+    emit({nl,"begin",nl}),
+
+    asn1ct_name:new(tmpval),
+    ExtAddGroupTypeName = asn1ct_gen:list2name([Cname|TopType]),
+    emit({{curr,tmpval}," = {'",ExtAddGroupTypeName,"', "}),
+    ExtNames = [ExtName||#'ComponentType'{name=ExtName}<-ExtGroupCompList],
+    Elements = make_elements(Pos+1,"Val1",ExtNames),
+    emit({Elements,"},"}),
+      InnerType = asn1ct_gen:get_inner(Type#type.def),
+    emit({nl,"%% attribute number ",Pos," with type ",
+	      InnerType,nl}),
+    NextElement = asn1ct_gen:mk_var(asn1ct_name:curr(tmpval)),
+    gen_enc_line(Erule,TopType,Cname,Type,NextElement, Pos,DynamicEnc,Ext),
+    emit({nl,"end"});
 gen_enc_component_optional(Erule,TopType,Cname,Type,Pos,DynamicEnc,Ext) ->
     Element = make_element(Pos+1,"Val1",Cname),
     emit({"case ",Element," of",nl}),
@@ -834,29 +891,7 @@ gen_enc_line(Erule,TopType,Cname,Type,Element, _Pos,DynamicEnc,Ext) ->
 	_ -> true
     end.
 gen_dec_components_call(Erule,TopType,{Root1,ExtList,Root2},MaybeComma,DecInfObj,Ext,NumberOfOptionals) ->
-     %% The type has extensionmarker
-     OptTable = create_optionality_table(Root1 ++ Root2),
-     {Rpos,AccTerm,AccBytes} = 
- 	gen_dec_components_call1(Erule,TopType, Root1, 1, OptTable,
- 				 MaybeComma,DecInfObj, noext,[],[],
- 				 NumberOfOptionals),
-     emit([",",nl,"{Extensions,",{next,bytes},"} = "]),
-     emit(["?RT_PER:getextension(Ext,",{curr,bytes},"),",nl]),
-     asn1ct_name:new(bytes),
-     {Epos,AccTermE,AccBytesE} = 
- 	gen_dec_components_call1(Erule,TopType,ExtList,Rpos, OptTable, "",
- 				 DecInfObj,Ext,[],[],NumberOfOptionals),
-     case ExtList of
- 	[] -> true;
- 	_ -> emit([",",nl])
-     end,
-     emit([{next,bytes},"= ?RT_PER:skipextensions(",{curr,bytes},",",
- 	  length(ExtList)+1,",Extensions),",nl]),
-     asn1ct_name:new(bytes),
-     {_RPos2,AccTerm2,AccBytes2} =
- 	gen_dec_components_call1(Erule,TopType,Root2,Epos,OptTable,
- 				 "",DecInfObj,noext,[],[],NumberOfOptionals),
-     {AccTerm++AccTermE++AccTerm2,AccBytes++AccBytesE++AccBytes2};
+    gen_dec_components_call(Erule,TopType,{Root1++Root2,ExtList},MaybeComma,DecInfObj,Ext,NumberOfOptionals);
 gen_dec_components_call(Erule,TopType,{CompList,ExtList},MaybeComma,
 			DecInfObj,Ext,NumberOfOptionals) ->
     %% The type has extensionmarker
@@ -868,8 +903,9 @@ gen_dec_components_call(Erule,TopType,{CompList,ExtList},MaybeComma,
     emit([",",nl,"{Extensions,",{next,bytes},"} = "]),
     emit(["?RT_PER:getextension(Ext,",{curr,bytes},"),",nl]),
     asn1ct_name:new(bytes),
+    NewExtList = wrap_extensionAdditionGroups(ExtList),
     {_Epos,AccTermE,AccBytesE} = 
-	gen_dec_components_call1(Erule,TopType,ExtList,Rpos, OptTable,
+	gen_dec_components_call1(Erule,TopType,NewExtList,Rpos, OptTable,
 				 "",DecInfObj,Ext,[],[],NumberOfOptionals),
     case ExtList of
 	[] -> true;
@@ -942,8 +978,18 @@ gen_dec_components_call1(Erule,TopType,
 	    asn1ct_name:new(tmpterm),
 	    emit({"{",{curr,tmpterm},", ",{next,bytes},"} = "});
 	_ ->
-	    asn1ct_name:new(term),
-	    emit({"{",{curr,term},",",{next,bytes},"} = "})
+	    case Type of
+		#type{def=#'SEQUENCE'{
+			extaddgroup=Number1,
+			components=ExtGroupCompList1}} when is_integer(Number1)->
+		    emit({"{{_,"}),
+		    emit_extaddgroupTerms(term,ExtGroupCompList1),
+		    emit({"}"});
+		_ ->
+		    asn1ct_name:new(term),
+		    emit({"{",{curr,term}})
+	    end,
+	    emit({",",{next,bytes},"} = "})
     end,
 
     case {Ext,Prop,is_optimized(Erule)} of
@@ -967,11 +1013,24 @@ gen_dec_components_call1(Erule,TopType,
 	{noext,mandatory} -> true; % generate nothing
 	{noext,_} ->
 	    emit([";",nl,"0 ->"]),
-	    gen_dec_component_no_val(TopType,Cname,Type,Prop,Tpos,Ext),
+	    emit(["{"]),
+	    gen_dec_component_no_val(Ext,Prop),
+	    emit({",",{curr,bytes},"}",nl}),
 	    emit([nl,"end"]);
 	_ ->
 	    emit([";",nl,"_  ->",nl]),
-	    gen_dec_component_no_val(TopType,Cname,Type,Prop,Tpos,Ext),
+	    emit(["{"]),
+	    case Type of
+		#type{def=#'SEQUENCE'{
+			extaddgroup=Number2,
+			components=ExtGroupCompList2}} when is_integer(Number2)->
+		    emit({"{extAddGroup,"}),
+		    gen_dec_extaddGroup_no_val(Ext,ExtGroupCompList2),
+		    emit({"}"});
+		_ ->
+		    gen_dec_component_no_val(Ext,Prop)
+	    end,
+	    emit({",",{curr,bytes},"}",nl}),
 	    emit([nl,"end"])
     end,    
     asn1ct_name:new(bytes),
@@ -988,13 +1047,22 @@ gen_dec_components_call1(Erule,TopType,
 gen_dec_components_call1(_,_TopType,[],Pos,_OptTable,_,_,_,AccTerm,AccBytes,_NumberOfOptionals) ->
     {Pos,AccTerm,AccBytes}.
 
-
-gen_dec_component_no_val(_,_,_,{'DEFAULT',DefVal},_,_) ->
-    emit(["{",{asis,DefVal},",",{curr,bytes},"}",nl]);
-gen_dec_component_no_val(_,_,_,'OPTIONAL',_,_) ->
-    emit({"{asn1_NOVALUE,",{curr,bytes},"}",nl});
-gen_dec_component_no_val(_,_,_,mandatory,_,{ext,_,_}) ->
-    emit({"{asn1_NOVALUE,",{curr,bytes},"}",nl}).
+gen_dec_extaddGroup_no_val(Ext,[#'ComponentType'{prop=Prop}])->
+    gen_dec_component_no_val(Ext,Prop),
+    ok;
+gen_dec_extaddGroup_no_val(Ext,[#'ComponentType'{prop=Prop}|Rest])->
+    gen_dec_component_no_val(Ext,Prop),
+    emit({","}),
+    gen_dec_extaddGroup_no_val(Ext,Rest);
+gen_dec_extaddGroup_no_val(_, []) ->
+    ok.
+
+gen_dec_component_no_val(_,{'DEFAULT',DefVal}) ->
+    emit([{asis,DefVal}]);
+gen_dec_component_no_val(_,'OPTIONAL') ->
+    emit({"asn1_NOVALUE"});
+gen_dec_component_no_val({ext,_,_},mandatory) ->
+    emit({"asn1_NOVALUE"}).
     
 
 gen_dec_line(Erule,TopType,Cname,Type,Pos,DecInfObj,Ext,Prop)  ->
@@ -1192,6 +1260,14 @@ gen_enc_choice_tag({C1,C2},_,_) ->
     N2 = get_name_list(C2),
     emit(["?RT_PER:set_choice(element(1,Val),",
 	  {asis,{N1,N2}},", ",{asis,{length(N1),length(N2)}},")"]);
+
+gen_enc_choice_tag({C1,C2,C3},_,_) ->
+    N1 = get_name_list(C1),
+    N2 = get_name_list(C2),
+    N3 = get_name_list(C3),
+    Root = N1 ++ N3,
+    emit(["?RT_PER:set_choice(element(1,Val),",
+	  {asis,{Root,N2}},", ",{asis,{length(Root),length(N2)}},")"]);
 gen_enc_choice_tag(C,_,_) ->
     N = get_name_list(C),
     emit(["?RT_PER:set_choice(element(1,Val),",
@@ -1208,6 +1284,8 @@ get_name_list([], Acc) ->
 
 gen_enc_choice2(Erule,TopType, {L1,L2}, Ext) ->
     gen_enc_choice2(Erule,TopType, L1 ++ L2, 0, Ext);
+gen_enc_choice2(Erule,TopType, {L1,L2,L3}, Ext) ->
+    gen_enc_choice2(Erule,TopType, L1 ++ L3 ++ L2, 0, Ext);
 gen_enc_choice2(Erule,TopType, L, Ext) ->
     gen_enc_choice2(Erule,TopType, L, 0, Ext).
 
@@ -1279,6 +1357,9 @@ gen_dec_choice1(Erule,TopType,CompList,noext) ->
 gen_dec_choice1(Erule,TopType,{RootList,ExtList},Ext) ->
     NewList = RootList ++ ExtList,
     gen_dec_choice1(Erule,TopType, NewList, Ext);
+gen_dec_choice1(Erule,TopType,{RootList,ExtList,RootList2},Ext) ->
+    NewList = RootList ++ RootList2 ++ ExtList,
+    gen_dec_choice1(Erule,TopType, NewList, Ext);
 gen_dec_choice1(Erule,TopType,CompList,{ext,ExtPos,ExtNum}) ->
     emit({"{Choice,",{curr,bytes},
 	  "} = ?RT_PER:getchoice(",{prev,bytes},",",
@@ -1347,6 +1428,18 @@ gen_encode_prim_wrapper(CtgenMod,Erule,Cont,DoTag,Value) ->
     CtgenMod:gen_encode_prim(Erule,Cont,DoTag,Value).
 %    erase(component_type).
 
+make_elements(I,Val,ExtCnames) ->
+    make_elements(I,Val,ExtCnames,[]).
+
+make_elements(I,Val,[ExtCname],Acc)-> % the last one, no comma needed
+    Element = make_element(I,Val,ExtCname),
+    make_elements(I+1,Val,[],[Element|Acc]);
+make_elements(I,Val,[ExtCname|Rest],Acc)->
+    Element = make_element(I,Val,ExtCname),
+    make_elements(I+1,Val,Rest,[", ",Element|Acc]);
+make_elements(_I,_,[],Acc) ->
+    lists:reverse(Acc).
+
 make_element(I,Val,Cname) ->
     case tuple_notation_allowed() of
 	true ->
@@ -1355,6 +1448,55 @@ make_element(I,Val,Cname) ->
 	    io_lib:format("element(~w,~s)",[I,Val])
     end.
 
+emit_extaddgroupTerms(VarSeries,[_]) ->
+    asn1ct_name:new(VarSeries),
+    emit({curr,VarSeries}),
+    ok;
+emit_extaddgroupTerms(VarSeries,[_|Rest]) ->
+    asn1ct_name:new(VarSeries),
+    emit({{curr,VarSeries},","}),
+    emit_extaddgroupTerms(VarSeries,Rest);
+emit_extaddgroupTerms(_,[]) ->
+    ok.
+wrap_compList({Root1,Ext,Root2}) ->
+    {Root1,wrap_extensionAdditionGroups(Ext),Root2};
+wrap_compList({Root1,Ext}) ->
+    {Root1,wrap_extensionAdditionGroups(Ext)};
+wrap_compList(CompList) ->
+    CompList.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%  Will convert all componentTypes following 'ExtensionAdditionGroup'
+%%  up to the matching 'ExtensionAdditionGroupEnd' into one componentType
+%% of type SEQUENCE with the componentTypes as components
+%%
+wrap_extensionAdditionGroups(ExtCompList) ->
+    wrap_extensionAdditionGroups(ExtCompList,[],0).
+
+wrap_extensionAdditionGroups([{'ExtensionAdditionGroup',_Number}|Rest],Acc,0) ->
+    {ExtGroupCompList=
+     [#'ComponentType'{textual_order=TextPos}|_],
+     ['ExtensionAdditionGroupEnd'|Rest2]} =
+	lists:splitwith(fun(#'ComponentType'{}) -> true;
+			   (_) -> false
+			end,
+			Rest),
+    wrap_extensionAdditionGroups(Rest2,
+				 [#'ComponentType'{
+                                  name='ExtAddGroup', % FIXME: handles ony one ExtAddGroup
+                                  typespec=#type{def=#'SEQUENCE'{
+						   extaddgroup=1,% FIXME: handles only one
+						   components=ExtGroupCompList}},
+                                  textual_order = TextPos,
+				  prop='OPTIONAL'}|Acc],length(ExtGroupCompList)-1);
+wrap_extensionAdditionGroups([H=#'ComponentType'{textual_order=Tord}|T],Acc,ExtAddGroupDiff) when is_integer(Tord) ->
+    wrap_extensionAdditionGroups(T,[H#'ComponentType'{
+				      textual_order=Tord - ExtAddGroupDiff}|Acc],ExtAddGroupDiff);
+wrap_extensionAdditionGroups([H|T],Acc,ExtAddGroupDiff) ->
+    wrap_extensionAdditionGroups(T,[H|Acc],ExtAddGroupDiff);
+wrap_extensionAdditionGroups([],Acc,_) ->
+    lists:reverse(Acc).
+
+
 tuple_notation_allowed() ->
     Options = get(encoding_options),
     not (lists:member(optimize,Options) orelse lists:member(uper_bin,Options)).