Normalize SIZE constraints to simplify backends

14 files changed, 214 insertions, 205 deletions

diff --git a/lib/asn1/src/asn1ct_check.erl b/lib/asn1/src/asn1ct_check.erl
index 80bd429e2c..4f1b0cac7a 100644
--- a/lib/asn1/src/asn1ct_check.erl
+++ b/lib/asn1/src/asn1ct_check.erl
@@ -4310,7 +4310,42 @@ normalize_cs([{'ValueRange',{Sv,Sv}}|Cs]) ->
     [{'SingleValue',Sv}|normalize_cs(Cs)];
 normalize_cs([{'ValueRange',{'MIN','MAX'}}|Cs]) ->
     normalize_cs(Cs);
-normalize_cs(Other) -> Other.
+normalize_cs([{'SizeConstraint',C0}|Cs]) ->
+    case normalize_size_constraint(C0) of
+	none ->
+	    normalize_cs(Cs);
+	C ->
+	    [{'SizeConstraint',C}|normalize_cs(Cs)]
+    end;
+normalize_cs([H|T]) ->
+    [H|normalize_cs(T)];
+normalize_cs([]) -> [].
+
+%% Normalize a size constraint to make it non-ambiguous and
+%% easy to interpret for the backends.
+%%
+%% Returns one of the following terms:
+%%  {LowerBound,UpperBound}
+%%  {{LowerBound,UpperBound},[]}     % Extensible
+%%  none                             % Remove size constraint from list
+%%
+%% where:
+%%  LowerBound = integer()
+%%  UpperBound = integer() | 'MAX'
+
+normalize_size_constraint(Sv) when is_integer(Sv) ->
+    {Sv,Sv};
+normalize_size_constraint({Root,Ext}) when is_list(Ext) ->
+    {normalize_size_constraint(Root),[]};
+normalize_size_constraint({{_,_},Ext}) when is_integer(Ext) ->
+    normalize_size_constraint(Ext);
+normalize_size_constraint([H|T]) ->
+    {H,lists:last(T)};
+normalize_size_constraint({0,'MAX'}) ->
+    none;
+normalize_size_constraint({Lb,Ub}=Range)
+  when is_integer(Lb), is_integer(Ub) orelse Ub =:= 'MAX' ->
+    Range.
 
 is_range(Prev, [H|T]) when Prev =:= H - 1 -> is_range(H, T);
 is_range(_, [_|_]) -> false;
diff --git a/lib/asn1/src/asn1ct_constructed_per.erl b/lib/asn1/src/asn1ct_constructed_per.erl
index 8c181aa2f0..bcd0a01bbb 100644
--- a/lib/asn1/src/asn1ct_constructed_per.erl
+++ b/lib/asn1/src/asn1ct_constructed_per.erl
@@ -502,12 +502,8 @@ gen_encode_sof(Erule,Typename,SeqOrSetOf,D) when is_record(D,type) ->
     asn1ct_name:start(),
     {_SeqOrSetOf,ComponentType} = D#type.def,
     emit({"[",nl}),
-    SizeConstraint =
-	case asn1ct_gen:get_constraint(D#type.constraint,
-				       'SizeConstraint') of
-	    no -> undefined;
-	    Range -> Range
-	end,
+    SizeConstraint = asn1ct_imm:effective_constraint(bitstring,
+						     D#type.constraint),
     ObjFun =
 	case D#type.tablecinf of
 	    [{objfun,_}|_R] ->
@@ -563,7 +559,7 @@ gen_encode_length(per, {Lb,Ub}) when Ub =< 65535, Lb >= 0 ->
 gen_encode_length(Erules, SizeConstraint) ->
     emit([nl,indent(3),
 	  case SizeConstraint of
-	      undefined ->
+	      no ->
 		  {call,Erules,encode_length,["length(Val)"]};
 	      _ ->
 		  {call,Erules,encode_length,
@@ -574,12 +570,8 @@ gen_encode_length(Erules, SizeConstraint) ->
 gen_decode_sof(Erules,Typename,SeqOrSetOf,D) when is_record(D,type) ->
     asn1ct_name:start(),
     {_SeqOrSetOf,ComponentType} = D#type.def,
-    SizeConstraint =
-	case asn1ct_gen:get_constraint(D#type.constraint,
-				       'SizeConstraint') of
-	    no -> undefined;
-	    Range -> Range
-	end,
+    SizeConstraint = asn1ct_imm:effective_constraint(bitstring,
+						     D#type.constraint),
     ObjFun =
 	case D#type.tablecinf of
 	    [{objfun,_}|_R] ->
diff --git a/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl b/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl
index 3a98cbb452..59653e383b 100644
--- a/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl
+++ b/lib/asn1/src/asn1ct_gen_ber_bin_v2.erl
@@ -154,7 +154,7 @@ gen_encode_user(Erules,D) when is_record(D,typedef) ->
     end.
 
 gen_encode_prim(Erules,D,DoTag,Value) when is_record(D,type) ->
-    BitStringConstraint = D#type.constraint,
+    BitStringConstraint = get_size_constraint(D#type.constraint),
     asn1ct_name:new(enumval),
     Type = case D#type.def of
 	       'OCTET STRING'    -> restricted_string;
@@ -459,11 +459,7 @@ gen_dec_prim(Erules,Att,BytesVar,DoTag,TagIn,Form,OptOrMand) ->
 %% Currently not used for BER replaced with [] as place holder
 %%    Constraint = Att#type.constraint,
 %% Constraint = [],
-    Constraint = 
-	case get_constraint(Att#type.constraint,'SizeConstraint') of
-	    no -> [];
-	    Tc -> Tc
-	end,
+    Constraint = get_size_constraint(Att#type.constraint),
     ValueRange = 
 	case get_constraint(Att#type.constraint,'ValueRange') of
 	    no -> [];
@@ -1480,6 +1476,14 @@ mkfuncname(WhatKind,DecOrEnc) ->
 	    
     end.
 
+get_size_constraint(C) ->
+    case lists:keyfind('SizeConstraint', 1, C) of
+	false -> [];
+	{_,{_,[]}} -> [];			%Extensible.
+	{_,{Sv,Sv}} -> Sv;
+	{_,{_,_}=Tc} -> Tc
+    end.
+
 get_constraint(C,Key) ->
     case lists:keysearch(Key,1,C) of
 	false ->
diff --git a/lib/asn1/src/asn1ct_gen_per.erl b/lib/asn1/src/asn1ct_gen_per.erl
index 2ffbe87ab2..3e35eb9f0e 100644
--- a/lib/asn1/src/asn1ct_gen_per.erl
+++ b/lib/asn1/src/asn1ct_gen_per.erl
@@ -118,6 +118,11 @@ gen_encode_prim(per=Erules, D, DoTag, Value) ->
     asn1ct_gen_per_rt2ct:gen_encode_prim(Erules, D, DoTag, Value);
 gen_encode_prim(Erules,D,DoTag,Value) when is_record(D,type) ->
     Constraint = D#type.constraint,
+    SizeConstr = asn1ct_imm:effective_constraint(bitstring, Constraint),
+    Pa = case lists:keyfind('PermittedAlphabet', 1, Constraint) of
+	     false -> no;
+	     {_,Pa0} -> Pa0
+	 end,
     asn1ct_name:new(enumval),
     case D#type.def of
 	'INTEGER' ->
@@ -132,7 +137,6 @@ gen_encode_prim(Erules,D,DoTag,Value) when is_record(D,type) ->
 	    emit_enc_real(Erules, Value);
 
 	{'BIT STRING',NamedNumberList} ->
-	    SizeConstr = get_constraint(Constraint, 'SizeConstraint'),
 	    call(Erules, encode_bit_string,
 		 [{asis,SizeConstr},Value,
 		  {asis,NamedNumberList}]);
@@ -148,7 +152,7 @@ gen_encode_prim(Erules,D,DoTag,Value) when is_record(D,type) ->
 	'BOOLEAN' ->
 	    call(Erules, encode_boolean, [Value]);
 	'OCTET STRING' ->
-	    case get_constraint(Constraint, 'SizeConstraint') of
+	    case SizeConstr of
 		0 ->
 		    emit("[]");
 		no ->
@@ -157,30 +161,38 @@ gen_encode_prim(Erules,D,DoTag,Value) when is_record(D,type) ->
 		    call(Erules, encode_octet_string, [{asis,C},Value])
 	    end;
 	'NumericString' ->
-	    call(Erules, encode_NumericString, [{asis,Constraint},Value]);
+	    call(Erules, encode_NumericString, [{asis,SizeConstr},
+						{asis,Pa},Value]);
 	TString when TString == 'TeletexString';
 		     TString == 'T61String' ->
 	    call(Erules, encode_TeletexString, [{asis,Constraint},Value]);
 	'VideotexString' ->
 	    call(Erules, encode_VideotexString, [{asis,Constraint},Value]);
 	'UTCTime' ->
-	    call(Erules, encode_VisibleString, [{asis,Constraint},Value]);
+	    call(Erules, encode_VisibleString, [{asis,SizeConstr},
+						{asis,Pa},Value]);
 	'GeneralizedTime' ->
-	    call(Erules, encode_VisibleString, [{asis,Constraint},Value]);
+	    call(Erules, encode_VisibleString, [{asis,SizeConstr},
+						{asis,Pa},Value]);
 	'GraphicString' ->
 	    call(Erules, encode_GraphicString, [{asis,Constraint},Value]);
 	'VisibleString' ->
-	    call(Erules, encode_VisibleString, [{asis,Constraint},Value]);
+	    call(Erules, encode_VisibleString, [{asis,SizeConstr},
+						{asis,Pa},Value]);
 	'GeneralString' ->
 	    call(Erules, encode_GeneralString, [{asis,Constraint},Value]);
 	'PrintableString' ->
-	    call(Erules, encode_PrintableString, [{asis,Constraint},Value]);
+	    call(Erules, encode_PrintableString, [{asis,SizeConstr},
+						  {asis,Pa},Value]);
 	'IA5String' ->
-	    call(Erules, encode_IA5String, [{asis,Constraint},Value]);
+	    call(Erules, encode_IA5String, [{asis,SizeConstr},
+					    {asis,Pa},Value]);
 	'BMPString' ->
-	    call(Erules, encode_BMPString, [{asis,Constraint},Value]);
+	    call(Erules, encode_BMPString, [{asis,SizeConstr},
+					    {asis,Pa},Value]);
 	'UniversalString' ->
-	    call(Erules, encode_UniversalString, [{asis,Constraint},Value]);
+	    call(Erules, encode_UniversalString, [{asis,SizeConstr},
+						  {asis,Pa},Value]);
 	'UTF8String' ->
 	    call(Erules, encode_UTF8String, [Value]);
 	'ANY' ->
@@ -252,16 +264,6 @@ enc_ext_and_val(uper, E, F, Args) ->
     <<E:1,(apply(asn1ct_eval_uper, F, Args))/bitstring>>.
 
 
-get_constraint([{Key,V}], Key) ->
-    V;
-get_constraint([], _) ->
-    no;
-get_constraint(C, Key) ->
-    case lists:keyfind(Key, 1, C) of
-	false -> no;
-	{Key,V} -> V
-    end.
-
 %% Object code generating for encoding and decoding
 %% ------------------------------------------------
 
@@ -1016,7 +1018,7 @@ gen_dec_imm_1('ASN1_OPEN_TYPE', Constraint, Aligned) ->
 gen_dec_imm_1('ANY', _Constraint, Aligned) ->
     imm_decode_open_type([], Aligned);
 gen_dec_imm_1({'BIT STRING',NNL}, Constr0, Aligned) ->
-    Constr = get_constraint(Constr0, 'SizeConstraint'),
+    Constr = asn1ct_imm:effective_constraint(bitstring, Constr0),
     Imm = asn1ct_imm:per_dec_raw_bitstring(Constr, Aligned),
     case NNL of
 	[] ->
@@ -1069,7 +1071,7 @@ gen_dec_imm_1('UTCTime', Constraint, Aligned) ->
 gen_dec_imm_1('GeneralizedTime', Constraint, Aligned) ->
     gen_dec_k_m_string('VisibleString', Constraint, Aligned);
 gen_dec_imm_1('OCTET STRING', Constraint, Aligned) ->
-    SzConstr = get_constraint(Constraint, 'SizeConstraint'),
+    SzConstr = asn1ct_imm:effective_constraint(bitstring, Constraint),
     Imm = asn1ct_imm:per_dec_octet_string(SzConstr, Aligned),
     {convert,binary_to_list,Imm};
 gen_dec_imm_1('TeletexString', _Constraint, Aligned) ->
diff --git a/lib/asn1/src/asn1ct_gen_per_rt2ct.erl b/lib/asn1/src/asn1ct_gen_per_rt2ct.erl
index 4eddba3150..1a16054fa0 100644
--- a/lib/asn1/src/asn1ct_gen_per_rt2ct.erl
+++ b/lib/asn1/src/asn1ct_gen_per_rt2ct.erl
@@ -139,11 +139,7 @@ emit_enc_real(Erules, Real) ->
 	  "end"]).
 
 emit_enc_known_multiplier_string(StringType,C,Value) ->
-    SizeC = 
-	case get_constraint(C,'SizeConstraint') of
-	    L when is_list(L) -> {lists:min(L),lists:max(L)};
-	    L -> L
-	end,
+    SizeC = effective_constraint(bitstring, C),
     PAlphabC = get_constraint(C,'PermittedAlphabet'),
     case {StringType,PAlphabC} of
 	{'UniversalString',{_,_}} ->
@@ -268,7 +264,7 @@ charbits1(NumOfChars) ->
 %% copied from run time module
 
 emit_enc_octet_string(Erules, Constraint, Value) ->
-    case get_constraint(Constraint,'SizeConstraint') of
+    case effective_constraint(bitstring, Constraint) of
 	0 ->
 	    emit({"  []"});
 	1 ->
diff --git a/lib/asn1/src/asn1ct_imm.erl b/lib/asn1/src/asn1ct_imm.erl
index e0e4a5a451..5585cad925 100644
--- a/lib/asn1/src/asn1ct_imm.erl
+++ b/lib/asn1/src/asn1ct_imm.erl
@@ -95,18 +95,16 @@ per_dec_integer(Constraint0, Aligned) ->
 
 per_dec_length(SingleValue, _, _Aligned) when is_integer(SingleValue) ->
     {value,SingleValue};
-per_dec_length({S,S}, _, _Aligned) when is_integer(S) ->
-    {value,S};
-per_dec_length({{_,_}=Constr,_}, AllowZero, Aligned) ->
+per_dec_length({{Fixed,Fixed},[]}, AllowZero, Aligned) ->
+    bit_case(per_dec_length(Fixed, AllowZero, Aligned),
+	     per_dec_length(no, AllowZero, Aligned));
+per_dec_length({{_,_}=Constr,[]}, AllowZero, Aligned) ->
     bit_case(per_dec_length(Constr, AllowZero, Aligned),
-	     per_dec_length(undefined, AllowZero, Aligned));
+	     per_dec_length(no, AllowZero, Aligned));
 per_dec_length({Lb,Ub}, _AllowZero, Aligned) when is_integer(Lb),
-						  is_integer(Lb),
-						  Ub =< 65535 ->
+						  is_integer(Lb) ->
     per_dec_constrained(Lb, Ub, Aligned);
-per_dec_length({_,_}, AllowZero, Aligned) ->
-    decode_unconstrained_length(AllowZero, Aligned);
-per_dec_length(undefined, AllowZero, Aligned) ->
+per_dec_length(no, AllowZero, Aligned) ->
     decode_unconstrained_length(AllowZero, Aligned).
 
 per_dec_named_integer(Constraint, NamedList0, Aligned) ->
@@ -115,7 +113,7 @@ per_dec_named_integer(Constraint, NamedList0, Aligned) ->
     {map,Int,NamedList}.
 
 per_dec_k_m_string(StringType, Constraint, Aligned) ->
-    SzConstr = get_constraint(Constraint, 'SizeConstraint'),
+    SzConstr = effective_constraint(bitstring, Constraint),
     N = string_num_bits(StringType, Constraint, Aligned),
     %% X.691 (07/2002) 27.5.7 says if the upper bound times the number
     %% of bits is greater than or equal to 16, then the bit field should
@@ -159,18 +157,17 @@ per_dec_restricted_string(Aligned) ->
 %%% Local functions.
 %%%
 
-dec_string(Sv, U, Aligned0, AF) when is_integer(Sv), Sv < 16#10000 ->
+dec_string(Sv, U, Aligned0, AF) when is_integer(Sv) ->
     Bits = U*Sv,
     Aligned = Aligned0 andalso AF(Bits, Bits),
     {get_bits,Sv,[U,binary,{align,Aligned}]};
-dec_string([_|_]=C, U, Aligned, AF) when is_list(C) ->
-    dec_string({hd(C),lists:max(C)}, U, Aligned, AF);
-dec_string({Sv,Sv}, U, Aligned, AF) ->
-    dec_string(Sv, U, Aligned, AF);
-dec_string({{_,_}=C,_}, U, Aligned, AF) ->
+dec_string({{Sv,Sv},[]}, U, Aligned, AF) ->
+    bit_case(dec_string(Sv, U, Aligned, AF),
+	     dec_string(no, U, Aligned, AF));
+dec_string({{_,_}=C,[]}, U, Aligned, AF) ->
     bit_case(dec_string(C, U, Aligned, AF),
 	     dec_string(no, U, Aligned, AF));
-dec_string({Lb,Ub}, U, Aligned0, AF) when Ub < 16#10000 ->
+dec_string({Lb,Ub}, U, Aligned0, AF) ->
     Len = per_dec_constrained(Lb, Ub, Aligned0),
     Aligned = Aligned0 andalso AF(Lb*U, Ub*U),
     {get_bits,Len,[U,binary,{align,Aligned}]};
@@ -712,7 +709,27 @@ effective_constraint(integer, C) ->
     VR = effective_constr('ValueRange', VRs),
     greatest_common_range(SV, VR);
 effective_constraint(bitstring, C) ->
-    get_constraint(C, 'SizeConstraint').
+    case get_constraint(C, 'SizeConstraint') of
+	{{Lb,Ub},[]}=Range when is_integer(Lb) ->
+	    if
+		is_integer(Ub), Ub < 16#10000 ->
+		    Range;
+		true ->
+		    no
+	    end;
+	{Lb,Ub}=Range when is_integer(Lb) ->
+	    if
+		is_integer(Ub), Ub < 16#10000 ->
+		    if
+			Lb =:= Ub -> Lb;
+			true -> Range
+		    end;
+		true ->
+		    no
+	    end;
+	no ->
+	    no
+    end.
 
 effective_constr(_, []) -> [];
 effective_constr('SingleValue', List) ->
diff --git a/lib/asn1/src/asn1rtt_ber.erl b/lib/asn1/src/asn1rtt_ber.erl
index 34f246fb22..509c091355 100644
--- a/lib/asn1/src/asn1rtt_ber.erl
+++ b/lib/asn1/src/asn1rtt_ber.erl
@@ -838,8 +838,8 @@ int_to_bitlist(Int) when is_integer(Int), Int >= 0 ->
 %% and BinBits is a binary representing the BIT STRING.
 %%=================================================================
 encode_bin_bit_string(C,{Unused,BinBits},_NamedBitList,TagIn)->
-    case get_constraint(C,'SizeConstraint') of
-	no ->
+    case C of
+	[] ->
 	    remove_unused_then_dotag(TagIn, Unused, BinBits);
 	{_Min,Max} ->
 	    BBLen = (byte_size(BinBits)*8)-Unused,
@@ -885,8 +885,8 @@ 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 get_constraint(C,'SizeConstraint') of
-	    no ->
+	case C of
+	    [] ->
 		lists:max(ToSetPos)+1;
 	    {_Min,Max} ->
 		Max;
@@ -943,8 +943,8 @@ make_and_set_list(Len, [], XPos) ->
 %% Encode bit string for lists of ones and zeroes
 %%=================================================================
 encode_bit_string_bits(C, BitListVal, _NamedBitList, TagIn) when is_list(BitListVal) ->
-    case get_constraint(C,'SizeConstraint') of
-	no ->
+    case C of
+	[] ->
 	    {Len, Unused, OctetList} = encode_bitstring(BitListVal),
 	    %%add unused byte to the Len
 	    encode_tags(TagIn, [Unused | OctetList], Len+1);
@@ -957,7 +957,7 @@ encode_bit_string_bits(C, BitListVal, _NamedBitList, TagIn) when is_list(BitList
 	Constr={{_,_},{_,_}} ->%{{Min1,Max1},{Min2,Max2}}
 	    %% constraint with extension mark
 	    encode_constr_bit_str_bits(Constr,BitListVal,TagIn);
-	Size ->
+	Size when is_integer(Size) ->
 	    case length(BitListVal) of
 		BitSize when BitSize == Size ->
 		    {Len, Unused, OctetList} = encode_bitstring(BitListVal),
@@ -1266,22 +1266,14 @@ 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, StrLen, Range) ->
-    case Range of
-	{Lb,Ub} when StrLen >= Lb, Ub >= StrLen -> % variable length constraint
-	    Val;
-	{_,Ext} when is_list(Ext) ->
-	    Val;
-	StrLen -> % fixed length constraint
-	    Val;
-	{_,_} ->
-	    exit({error,{asn1,{length,Range,Val}}});
-	_Len when is_integer(_Len) ->
-	    exit({error,{asn1,{length,Range,Val}}});
-	_ -> % some strange constraint that we don't support yet
-	    Val
-    end.
-
+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}}}).
 
 %%============================================================================
 %% encode Universal string
@@ -1530,14 +1522,6 @@ match_and_collect(Tlv, TagsIn) ->
 	    Bin
     end.
 
-get_constraint(C, Key) ->
-    case lists:keyfind(Key, 1, C) of
-	false ->
-	    no;
-	{_,V} ->
-	    V
-    end.
-
 collect_parts(TlvList) ->
     collect_parts(TlvList, []).
 
diff --git a/lib/asn1/src/asn1rtt_per.erl b/lib/asn1/src/asn1rtt_per.erl
index 8d2025d603..74ae11632d 100644
--- a/lib/asn1/src/asn1rtt_per.erl
+++ b/lib/asn1/src/asn1rtt_per.erl
@@ -347,22 +347,17 @@ encode_length(Len) ->				% unconstrained
 	    exit({error,{asn1,{encode_length,{nyi,above_16k}}}})
     end.
 
-encode_length(undefined, Len) -> % un-constrained
-    encode_length(Len);
-encode_length({0,'MAX'},Len) ->
-    encode_length(undefined,Len);
-encode_length({Lb,Ub}=Vr, Len) when Ub =< 65535 ,Lb >= 0 -> % constrained
-    encode_constrained_number(Vr,Len);
-encode_length({Lb,_Ub}, Len) when is_integer(Lb), Lb >= 0 -> % Ub > 65535
-    encode_length(Len);
-encode_length({{Lb,Ub}=Vr,Ext}, Len)
-  when Ub =< 65535, Lb =< Len, Len =< Ub, is_list(Ext) ->
-    %% constrained extensible
-    [0|encode_constrained_number(Vr,Len)];
-encode_length({{_,_},Ext},Len) when is_list(Ext) ->
-    [1|encode_length(Len)];
-encode_length(SingleValue, _Len) when is_integer(SingleValue) ->
-    [].
+encode_length({C,[]}, Len) ->
+    case C of
+	{Lb,Ub}=Vr when Lb =< Len, Len =< Ub ->
+	    [0|encode_constrained_number(Vr, Len)];
+	_ ->
+	    [1|encode_length(Len)]
+    end;
+encode_length(Len, Len) ->
+    [];
+encode_length(Vr, Len) ->
+    encode_constrained_number(Vr, Len).
 
 %% X.691 10.9.3.4 (only used for length of bitmap that prefixes extension
 %% additions in a sequence or set
@@ -684,15 +679,6 @@ encode_octet_string({_,_}=SZ, Val) ->
 	exit:{error,{asn1,{encode_length,_}}} ->
 	    encode_fragmented_octet_string(Val)
     end;
-encode_octet_string(SZ, Val) when is_list(SZ) ->
-    Len = length(Val),
-    try
-	[encode_length({hd(SZ),lists:max(SZ)},Len),2|
-	 octets_to_complete(Len,Val)]
-    catch
-	exit:{error,{asn1,{encode_length,_}}} ->
-	    encode_fragmented_octet_string(Val)
-    end;
 encode_octet_string(Sv, Val) when is_integer(Sv) ->
     encode_fragmented_octet_string(Val);
 encode_octet_string(no, Val) ->
@@ -702,9 +688,7 @@ encode_octet_string(no, Val) ->
     catch
 	exit:{error,{asn1,{encode_length,_}}} ->
 	    encode_fragmented_octet_string(Val)
-    end;
-encode_octet_string(C, _) ->
-    exit({error,{not_implemented,C}}).
+    end.
 
 encode_fragmented_octet_string(Val) ->
     Bin = iolist_to_binary(Val),
@@ -740,7 +724,7 @@ encode_known_multiplier_string(SizeC, NumBits, CharOutTab, Val) ->
     case SizeC of
 	Ub when is_integer(Ub), Ub*NumBits < 16  ->
 	    Result;
-	Ub when is_integer(Ub), Ub =<65535 -> % fixed length
+	Ub when is_integer(Ub) ->
 	    [2,Result];
 	{{_,Ub},Ext}=SZ when is_list(Ext) ->
 	    Len = length(Val),
diff --git a/lib/asn1/src/asn1rtt_uper.erl b/lib/asn1/src/asn1rtt_uper.erl
index 0a543ea6d7..8cf23a9239 100644
--- a/lib/asn1/src/asn1rtt_uper.erl
+++ b/lib/asn1/src/asn1rtt_uper.erl
@@ -34,17 +34,17 @@
 
  -export([encode_open_type/1]).
 
- -export([encode_UniversalString/2,
-	 encode_PrintableString/2,
+ -export([encode_UniversalString/3,
+	 encode_PrintableString/3,
 	 encode_GeneralString/2,
 	 encode_GraphicString/2,
 	 encode_TeletexString/2,
 	 encode_VideotexString/2,
-	 encode_VisibleString/2,
+	 encode_VisibleString/3,
 	 encode_UTF8String/1,
-	 encode_BMPString/2,
-	 encode_IA5String/2,
-	 encode_NumericString/2,
+	 encode_BMPString/3,
+	 encode_IA5String/3,
+	 encode_NumericString/3,
 	 encode_ObjectDescriptor/2
 	]).
 
@@ -346,22 +346,18 @@ encode_length(Len) -> % un-constrained
 	    error({error,{asn1,{encode_length,{nyi,above_16k}}}})
     end.
 
-encode_length(undefined, Len) ->		% unconstrained
-    encode_length(Len);
-encode_length({0,'MAX'},Len) ->
-    encode_length(undefined, Len);
-encode_length({Lb,Ub}=Vr, Len) when Ub =< 65535, Lb >= 0 -> % constrained
-    encode_constrained_number(Vr,Len);
-encode_length({Lb,_Ub}, Len) when is_integer(Lb), Lb >= 0 -> % Ub > 65535
-    encode_length(Len);
-encode_length({{Lb,Ub}=Vr,Ext},Len)
-  when Ub =< 65535, Lb =< Len, Len =< Ub, is_list(Ext) ->
-    %% constrained extensible
-    [<<0:1>>,encode_constrained_number(Vr,Len)];
-encode_length({{_Lb,_Ub},Ext}, Len) when is_list(Ext) ->
-    [<<1:1>>,encode_length(Len)];
-encode_length(SingleValue, _Len) when is_integer(SingleValue) ->
-    [].
+encode_length({C,[]}, Len) ->
+    case C of
+	{Lb,Ub}=Vr when Lb =< Len, Len =< Ub ->
+	    [<<0:1>>|encode_constrained_number(Vr, Len)];
+	_ ->
+	    [<<1:1>>|encode_length(Len)]
+    end;
+encode_length(Len, Len) ->
+    [];
+encode_length(Vr, Len) ->
+    encode_constrained_number(Vr, Len).
+
 
 %% X.691 10.9.3.4 (only used for length of bitmap that prefixes extension
 %% additions in a sequence or set
@@ -643,10 +639,6 @@ encode_octet_string(Val) ->
 
 encode_octet_string(C, Val) ->
     case C of
-	1 ->
-	    list_to_binary(Val);
-	2 ->
-	    list_to_binary(Val);
 	{_,_}=VR  ->
 	    try
 		[encode_length(VR, length(Val)),list_to_binary(Val)]
@@ -655,20 +647,7 @@ encode_octet_string(C, Val) ->
 		    encode_fragmented_octet_string(Val)
 	    end;
 	Sv when is_integer(Sv), Sv =:= length(Val) -> % fixed length
-	    if
-		Sv =< 65535 ->
-		    list_to_binary(Val);
-		true ->
-		    encode_fragmented_octet_string(Val)
-	    end;
-	Sv when is_list(Sv) ->
-	    try
-		[encode_length({hd(Sv),lists:max(Sv)},
-			       length(Val)),list_to_binary(Val)]
-	    catch
-		error:{error,{asn1,{encode_length,_}}} ->
-		    encode_fragmented_octet_string(Val)
-	    end
+	    list_to_binary(Val)
     end.
 
 
@@ -698,41 +677,34 @@ efos_1(<<B/bitstring>>) ->
 encode_restricted_string(Val) when is_list(Val)->
     [encode_length(length(Val)),list_to_binary(Val)].
 
-encode_known_multiplier_string(StringType, C, Val) ->
-    Result = chars_encode(C, StringType, Val),
-    NumBits = get_NumBits(C, StringType),
-    case get_constraint(C, 'SizeConstraint') of
-	Ub when is_integer(Ub), Ub*NumBits =< 16  ->
-	    Result;
-	0 ->
-	    [];
-	Ub when is_integer(Ub),Ub =<65535 -> % fixed length
+encode_known_multiplier_string(StringType, C, Pa, Val) ->
+    Result = chars_encode(Pa, StringType, Val),
+    case C of
+	Ub when is_integer(Ub) ->
 	    Result;
-	{Ub,Lb} ->
-	    [encode_length({Ub,Lb}, length(Val)),Result];
-	Vl when is_list(Vl) ->
-	    [encode_length({lists:min(Vl),lists:max(Vl)}, length(Val)),Result];
+	{_,_}=Range ->
+	    [encode_length(Range, length(Val)),Result];
 	no  ->
 	    [encode_length(length(Val)),Result]
     end.
 
-encode_NumericString(C,Val) ->
-    encode_known_multiplier_string('NumericString',C,Val).
+encode_NumericString(C, Pa, Val) ->
+    encode_known_multiplier_string('NumericString', C, Pa, Val).
 
-encode_PrintableString(C,Val) ->
-    encode_known_multiplier_string('PrintableString',C,Val).
+encode_PrintableString(C, Pa, Val) ->
+    encode_known_multiplier_string('PrintableString', C, Pa, Val).
 
-encode_VisibleString(C,Val) -> % equivalent with ISO646String
-    encode_known_multiplier_string('VisibleString',C,Val).
+encode_VisibleString(C, Pa, Val) -> % equivalent with ISO646String
+    encode_known_multiplier_string('VisibleString', C, Pa, Val).
 
-encode_IA5String(C,Val) ->
-    encode_known_multiplier_string('IA5String',C,Val).
+encode_IA5String(C, Pa, Val) ->
+    encode_known_multiplier_string('IA5String', C, Pa, Val).
 
-encode_BMPString(C,Val) ->
-    encode_known_multiplier_string('BMPString',C,Val).
+encode_BMPString(C, Pa, Val) ->
+    encode_known_multiplier_string('BMPString', C, Pa, Val).
 
-encode_UniversalString(C,Val) ->
-    encode_known_multiplier_string('UniversalString',C,Val).
+encode_UniversalString(C, Pa, Val) ->
+    encode_known_multiplier_string('UniversalString', C, Pa, Val).
 
 
 %% end of known-multiplier strings for which PER visible constraints are
@@ -761,14 +733,15 @@ encode_VideotexString(_C,Val) ->
 %% into account.
 %% This function does only encode the value part and NOT the length
 
-chars_encode(C,StringType,Value) ->
-    case {StringType,get_constraint(C,'PermittedAlphabet')} of
+chars_encode(Pa, StringType, Value) ->
+    case {StringType,Pa} of
 	{'UniversalString',{_,_Sv}} ->
 	    exit({error,{asn1,{'not implemented',"UniversalString with PermittedAlphabet constraint"}}});
 	{'BMPString',{_,_Sv}} ->
 	    exit({error,{asn1,{'not implemented',"BMPString with PermittedAlphabet constraint"}}});
 	_ ->
-	    {NumBits,CharOutTab} = {get_NumBits(C,StringType),get_CharOutTab(C,StringType)},
+	    {NumBits,CharOutTab} = {get_NumBits(Pa, StringType),
+				    get_CharOutTab(Pa, StringType)},
 	    chars_encode2(Value,NumBits,CharOutTab)
     end.
 
@@ -795,8 +768,8 @@ exit_if_false(V,false)->
 exit_if_false(_,V) ->V.
 
 
-get_NumBits(C,StringType) ->
-    case get_constraint(C,'PermittedAlphabet') of
+get_NumBits(Pa, StringType) ->
+    case Pa of
 	{'SingleValue',Sv} ->
 	    charbits(length(Sv));
 	no ->
@@ -816,22 +789,23 @@ get_NumBits(C,StringType) ->
 	    end
     end.
 
-get_CharOutTab(C,StringType) ->
-    case get_constraint(C,'PermittedAlphabet') of
+get_CharOutTab(Pa, StringType) ->
+    case Pa of
 	{'SingleValue',Sv} ->
-	    get_CharTab2(C,StringType,hd(Sv),lists:max(Sv),Sv);
+	    get_CharTab2(Pa, StringType, hd(Sv), lists:max(Sv), Sv);
 	no ->
 	    case StringType of
 		'IA5String' ->
 		    {0,16#7F,notab};
 		'VisibleString' ->
-		    get_CharTab2(C,StringType,16#20,16#7F,notab);
+		    get_CharTab2(Pa, StringType, 16#20, 16#7F, notab);
 		'PrintableString' ->
 		    Chars = lists:sort(
 			      " '()+,-./0123456789:=?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"),
-		    get_CharTab2(C,StringType,hd(Chars),lists:max(Chars),Chars);
+		    get_CharTab2(Pa, StringType, hd(Chars),
+				 lists:max(Chars), Chars);
 		'NumericString' ->
-		    get_CharTab2(C,StringType,16#20,$9," 0123456789");
+		    get_CharTab2(Pa, StringType, 16#20, $9, " 0123456789");
 		'UniversalString' ->
 		    {0,16#FFFFFFFF,notab};
 		'BMPString' ->
diff --git a/lib/asn1/test/asn1_SUITE.erl b/lib/asn1/test/asn1_SUITE.erl
index 8deabece37..0c5ba43a5f 100644
--- a/lib/asn1/test/asn1_SUITE.erl
+++ b/lib/asn1/test/asn1_SUITE.erl
@@ -655,7 +655,6 @@ constraint_equivalence(Config) ->
     AbsFile = filename:join(CaseDir, Asn1Spec++".abs"),
     {ok,Terms} = file:consult(AbsFile),
     Cs = [begin
-	      'INTEGER' = element(3, Type),	%Assertion.
 	      Constraints = element(4, Type),
 	      Name1 = atom_to_list(Name0),
 	      {Name,_} = lists:splitwith(fun(C) -> C =/= $X end, Name1),
diff --git a/lib/asn1/test/asn1_SUITE_data/ConstraintEquivalence.asn1 b/lib/asn1/test/asn1_SUITE_data/ConstraintEquivalence.asn1
index ad69553813..8b3d151502 100644
--- a/lib/asn1/test/asn1_SUITE_data/ConstraintEquivalence.asn1
+++ b/lib/asn1/test/asn1_SUITE_data/ConstraintEquivalence.asn1
@@ -43,6 +43,18 @@ BEGIN
  RangeX23 ::= INTEGER ((0..10) INTERSECTION (5..20) ^ (MIN..MAX))
  RangeX24 ::= INTEGER ((5|6|7|8|9|10) INTERSECTION (5..20) ^ (MIN..MAX))
 
+ UnconstrainedStringX00 ::= IA5String
+ UnconstrainedStringX01 ::= IA5String (SIZE (0..MAX))
+
+ ConstrainedStringX00 ::= IA5String (SIZE (0..5))
+ ConstrainedStringX01 ::= IA5String (SIZE (0|1|2|3|4|5))
+
+ -- Note: None of the back-ends care about the exact values
+ -- outside of the root range.
+ ExtConstrainedStringX00 ::= IA5String (SIZE (1..2, ...))
+ ExtConstrainedStringX01 ::= IA5String (SIZE (1|2, ..., 3))
+ ExtConstrainedStringX02 ::= IA5String (SIZE (1|2, ..., 3|4|5))
+
  integer4 INTEGER ::= 4
  integer11 INTEGER ::= 11
  integer42 INTEGER ::= 42
diff --git a/lib/asn1/test/asn1_SUITE_data/PrimStrings.asn1 b/lib/asn1/test/asn1_SUITE_data/PrimStrings.asn1
index 99fe38c07c..64fa5f4cd4 100644
--- a/lib/asn1/test/asn1_SUITE_data/PrimStrings.asn1
+++ b/lib/asn1/test/asn1_SUITE_data/PrimStrings.asn1
@@ -55,10 +55,15 @@ BS1024 ::= BIT STRING (SIZE (1024))
   OsExpCon ::= [60] EXPLICIT OCTET STRING
   OsExpPri ::= [PRIVATE 61] EXPLICIT  OCTET STRING
   OsExpApp ::= [APPLICATION 62] EXPLICIT OCTET STRING
+
   OsFrag ::= OCTET STRING (SIZE (0..100000))
   FixedOs65536 ::= OCTET STRING (SIZE (65536))
   FixedOs65537 ::= OCTET STRING (SIZE (65537))
 
+  OsFragExt ::= OCTET STRING (SIZE (0..100000, ...))
+  FixedOs65536Ext ::= OCTET STRING (SIZE (65536, ...))
+  FixedOs65537Ext ::= OCTET STRING (SIZE (65537, ...))
+
   OsFixedStrings ::= SEQUENCE {
     b1 BOOLEAN,  -- Unalign
     s0 OCTET STRING (SIZE (0)),
diff --git a/lib/asn1/test/testConstraints.erl b/lib/asn1/test/testConstraints.erl
index d245f6d1d5..fc217e45f7 100644
--- a/lib/asn1/test/testConstraints.erl
+++ b/lib/asn1/test/testConstraints.erl
@@ -142,6 +142,9 @@ int_constraints(Rules) ->
     roundtrip('FixedSize2', "0123456789"),
     roundtrip('FixedSize2', "0123456789abcdefghij"),
 
+    range_error(Rules, 'FixedSize', "short"),
+    range_error(Rules, 'FixedSize2', "short"),
+
     [roundtrip('VariableSize', lists:seq($A, $A+L-1)) ||
 	L <- lists:seq(1, 10)],
 
@@ -181,7 +184,7 @@ range_error(ber, Type, Value) ->
     %% BER: Values outside the effective range should be rejected
     %% on decode.
     {ok,Encoded} = 'Constraints':encode(Type, Value),
-    {error,{asn1,{integer_range,_,_}}} = 'Constraints':decode(Type, Encoded),
+    {error,{asn1,_}} = 'Constraints':decode(Type, Encoded),
     ok;
 range_error(Per, Type, Value) when Per =:= per; Per =:= uper ->
     %% (U)PER: Values outside the effective range should be rejected
diff --git a/lib/asn1/test/testPrimStrings.erl b/lib/asn1/test/testPrimStrings.erl
index 66415afe87..6f5a7f2437 100644
--- a/lib/asn1/test/testPrimStrings.erl
+++ b/lib/asn1/test/testPrimStrings.erl
@@ -276,10 +276,12 @@ fragmented_octet_string(Erules) ->
 	    K48-1,K48,K48+1,K48+(1 bsl 7)-1,K48+(1 bsl 7),K48+(1 bsl 7)+1,
 	    K64-1,K64,K64+1,K64+(1 bsl 7)-1,K64+(1 bsl 7),K64+(1 bsl 7)+1,
 	    K64+K16-1,K64+K16,K64+K16+1],
-    Types = ['Os','OsFrag'],
+    Types = ['Os','OsFrag','OsFragExt'],
     [fragmented_octet_string(Erules, Types, L) || L <- Lens],
     fragmented_octet_string(Erules, ['FixedOs65536'], 65536),
     fragmented_octet_string(Erules, ['FixedOs65537'], 65537),
+    fragmented_octet_string(Erules, ['FixedOs65536Ext'], 65536),
+    fragmented_octet_string(Erules, ['FixedOs65537Ext'], 65537),
 
     %% Make sure that octet alignment works.
     roundtrip('OsAlignment',