%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 2012-2013. 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_imm). -export([per_dec_raw_bitstring/2, per_dec_boolean/0,per_dec_enumerated/2,per_dec_enumerated/3, per_dec_extension_map/1, per_dec_integer/2,per_dec_k_m_string/3, per_dec_length/3,per_dec_named_integer/3, per_dec_octet_string/2,per_dec_open_type/1,per_dec_real/1, per_dec_restricted_string/1]). -export([per_dec_constrained/3,per_dec_normally_small_number/1]). -export([per_enc_bit_string/4,per_enc_legacy_bit_string/4, per_enc_boolean/2, per_enc_choice/3,per_enc_enumerated/3, per_enc_integer/3,per_enc_integer/4, per_enc_null/2, per_enc_k_m_string/4,per_enc_octet_string/3, per_enc_legacy_octet_string/3, per_enc_open_type/2, per_enc_restricted_string/3, per_enc_small_number/2]). -export([per_enc_extension_bit/2,per_enc_extensions/4,per_enc_optional/3]). -export([per_enc_sof/5]). -export([enc_absent/3,enc_append/1,enc_element/2]). -export([enc_cg/2]). -export([optimize_alignment/1,optimize_alignment/2, dec_slim_cg/2,dec_code_gen/2]). -export([effective_constraint/2]). -import(asn1ct_gen, [emit/1]). -record(st, {var, base}). dec_slim_cg(Imm0, BytesVar) -> {Imm,_} = optimize_alignment(Imm0), asn1ct_name:new(v), [H|T] = atom_to_list(asn1ct_name:curr(v)) ++ "@", VarBase = [H-($a-$A)|T], St0 = #st{var=0,base=VarBase}, {Res,Pre,_} = flatten(Imm, BytesVar, St0), dcg_list_outside(Pre), Res. dec_code_gen(Imm, BytesVar) -> emit(["begin",nl]), {Dst,DstBuf} = dec_slim_cg(Imm, BytesVar), emit([",",nl, "{",Dst,",",DstBuf,"}",nl, "end"]), ok. optimize_alignment(Imm) -> opt_al(Imm, unknown). optimize_alignment(Imm, Al) -> opt_al(Imm, Al). per_dec_boolean() -> {map,{get_bits,1,[1]},[{0,false},{1,true}]}. per_dec_enumerated([{V,_}], _Aligned) -> {value,V}; per_dec_enumerated(NamedList0, Aligned) -> Ub = length(NamedList0) - 1, Constraint = [{'ValueRange',{0,Ub}}], Int = per_dec_integer(Constraint, Aligned), 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), NamedListExt = per_dec_enumerated_fix_list(NamedListExt0, [enum_default], 0), Ext = {map,per_dec_normally_small_number(Aligned),NamedListExt}, bit_case(Base, Ext). per_dec_extension_map(Aligned) -> Len = per_dec_normally_small_length(Aligned), {get_bits,Len,[1,bitstring]}. per_dec_integer(Constraint0, Aligned) -> Constraint = effective_constraint(integer, Constraint0), per_dec_integer_1(Constraint, Aligned). per_dec_length(SingleValue, _, _Aligned) when is_integer(SingleValue) -> {value,SingleValue}; 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(no, AllowZero, Aligned)); per_dec_length({Lb,Ub}, _AllowZero, Aligned) when is_integer(Lb), is_integer(Lb) -> per_dec_constrained(Lb, Ub, Aligned); per_dec_length(no, AllowZero, Aligned) -> decode_unconstrained_length(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,opt_map(NamedList, Int)}. per_dec_k_m_string(StringType, Constraint, Aligned) -> SzConstr = effective_constraint(bitstring, Constraint), N = string_num_bits(StringType, Constraint, Aligned), Imm = dec_string(SzConstr, N, Aligned, k_m_string), Chars = char_tab(Constraint, StringType, N), convert_string(N, Chars, Imm). per_dec_octet_string(Constraint, Aligned) -> dec_string(Constraint, 8, Aligned, 'OCTET STRING'). per_dec_raw_bitstring(Constraint, Aligned) -> dec_string(Constraint, 1, Aligned, 'BIT STRING'). per_dec_open_type(Aligned) -> dec_string(no, 8, Aligned, open_type). per_dec_real(Aligned) -> Dec = fun(V, Buf) -> emit(["{",{call,real_common,decode_real,[V]}, com,Buf,"}"]) end, {call,Dec, {get_bits,decode_unconstrained_length(true, Aligned), [8,binary,{align,Aligned}]}}. per_dec_restricted_string(Aligned) -> DecLen = decode_unconstrained_length(true, Aligned), {get_bits,DecLen,[8,binary]}. %%% %%% Encoding. %%% per_enc_bit_string(Val, [], Constraint0, Aligned) -> {B,[[],Bits]} = mk_vars([], [bits]), Constraint = effective_constraint(bitstring, Constraint0), B ++ [{call,erlang,bit_size,[Val],Bits}| per_enc_length(Val, 1, Bits, Constraint, Aligned, 'BIT STRING')]; per_enc_bit_string(Val0, NNL0, Constraint0, Aligned) -> {B,[Val,Bs,Bits,Positions]} = mk_vars(Val0, [bs,bits,positions]), NNL = lists:keysort(2, NNL0), Constraint = effective_constraint(bitstring, Constraint0), ExtraArgs = case constr_min_size(Constraint) of no -> []; Lb -> [Lb] end, 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, B ++ [{'try', [bit_string_name2pos_fun(NNL, Val)], {Positions, [{call,per_common,bitstring_from_positions, [Positions|ExtraArgs]}]}, [ToBs],Bs}, {call,erlang,bit_size,[Bs],Bits}| per_enc_length(Bs, 1, Bits, Constraint, Aligned, 'BIT STRING')]. per_enc_legacy_bit_string(Val0, [], Constraint0, Aligned) -> {B,[Val,Bs,Bits]} = mk_vars(Val0, [bs,bits]), Constraint = effective_constraint(bitstring, Constraint0), ExtraArgs = case constr_min_size(Constraint) of no -> []; Lb -> [Lb] end, B ++ [{call,per_common,to_bitstring,[Val|ExtraArgs],Bs}, {call,erlang,bit_size,[Bs],Bits}| per_enc_length(Bs, 1, Bits, Constraint, Aligned, 'BIT STRING')]; per_enc_legacy_bit_string(Val0, NNL0, Constraint0, Aligned) -> {B,[Val,Bs,Bits,Positions]} = mk_vars(Val0, [bs,bits,positions]), NNL = lists:keysort(2, NNL0), Constraint = effective_constraint(bitstring, Constraint0), ExtraArgs = case constr_min_size(Constraint) of no -> []; 0 -> []; Lb -> [Lb] end, B ++ [{'try', [bit_string_name2pos_fun(NNL, Val)], {Positions, [{call,per_common,bitstring_from_positions, [Positions|ExtraArgs]}]}, [{call,per_common,to_named_bitstring,[Val|ExtraArgs]}],Bs}, {call,erlang,bit_size,[Bs],Bits}| per_enc_length(Bs, 1, Bits, Constraint, Aligned, 'BIT STRING')]. per_enc_boolean(Val0, _Aligned) -> {B,[Val]} = mk_vars(Val0, []), B++build_cond([[{eq,Val,false},{put_bits,0,1,[1]}], [{eq,Val,true},{put_bits,1,1,[1]}]]). per_enc_choice(Val0, Cs0, _Aligned) -> {B,[Val]} = mk_vars(Val0, []), Cs = [[{eq,Val,Tag}|opt_choice(Imm)] || {Tag,Imm} <- Cs0], B++build_cond(Cs). per_enc_enumerated(Val0, {Root,Ext}, Aligned) -> {B,[Val]} = mk_vars(Val0, []), Constr = enumerated_constraint(Root), RootCs = per_enc_enumerated_root(Root, [{put_bits,0,1,[1]}], Val, Constr, Aligned), ExtCs = per_enc_enumerated_ext(Ext, Val, Aligned), B++[{'cond',RootCs++ExtCs++enumerated_error(Val)}]; per_enc_enumerated(Val0, Root, Aligned) -> {B,[Val]} = mk_vars(Val0, []), Constr = enumerated_constraint(Root), Cs = per_enc_enumerated_root(Root, [], Val, Constr, Aligned), B++[{'cond',Cs++enumerated_error(Val)}]. enumerated_error(Val) -> [['_',{error,Val}]]. per_enc_integer(Val0, Constraint0, Aligned) -> {B,[Val]} = mk_vars(Val0, []), Constraint = effective_constraint(integer, Constraint0), B ++ per_enc_integer_1(Val, Constraint, Aligned). per_enc_integer(Val0, NNL, Constraint0, Aligned) -> {B,[Val]} = mk_vars(Val0, []), Constraint = effective_constraint(integer, Constraint0), Cs = [[{eq,Val,N}|per_enc_integer_1(V, Constraint, Aligned)] || {N,V} <- NNL], case per_enc_integer_1(Val, Constraint, Aligned) of [{'cond',IntCs}] -> B ++ [{'cond',Cs++IntCs}]; Other -> B ++ [{'cond',Cs++[['_'|Other]]}] end. per_enc_null(_Val, _Aligned) -> []. per_enc_k_m_string(Val0, StringType, Constraint, Aligned) -> {B,[Val,Bin,Len]} = mk_vars(Val0, [bin,len]), SzConstraint = effective_constraint(bitstring, Constraint), Unit = string_num_bits(StringType, Constraint, Aligned), Chars0 = char_tab(Constraint, StringType, Unit), Enc = case Unit of 16 -> {call,per_common,encode_chars_16bit,[Val],Bin}; 32 -> {call,per_common,encode_big_chars,[Val],Bin}; 8 -> {call,erlang,list_to_binary,[Val],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 -> B ++ [Enc,{call,erlang,byte_size,[Bin],Len}]; _ -> B ++ [{call,erlang,length,[Val],Len},Enc] end ++ per_enc_length(Bin, Unit, Len, SzConstraint, Aligned, k_m_string). per_enc_open_type(Imm0, Aligned) -> Imm = case Aligned of true -> %% Temporarily make the implicit 'align' done by %% complete/1 explicit to facilitate later %% optimizations: the absence of 'align' can be used %% as an indication that complete/1 can be replaced %% with a cheaper operation such as %% iolist_to_binary/1. The redundant 'align' will be %% optimized away later. Imm0 ++ [{put_bits,0,0,[1,align]}]; false -> Imm0 end, {[],[[],Val,Len,Bin]} = mk_vars([], [output,len,bin]), [{list,Imm,Val}, {call,enc_mod(Aligned),complete,[Val],Bin}, {call,erlang,byte_size,[Bin],Len}| per_enc_length(Bin, 8, Len, Aligned)]. per_enc_octet_string(Bin, Constraint0, Aligned) -> {B,[[],Len]} = mk_vars([], [len]), Constraint = effective_constraint(bitstring, Constraint0), B ++ [{call,erlang,byte_size,[Bin],Len}| per_enc_length(Bin, 8, Len, Constraint, Aligned, 'OCTET STRING')]. per_enc_legacy_octet_string(Val0, Constraint0, Aligned) -> {B,[Val,Bin,Len]} = mk_vars(Val0, [bin,len]), Constraint = effective_constraint(bitstring, Constraint0), B ++ [{call,erlang,iolist_to_binary,[Val],Bin}, {call,erlang,byte_size,[Bin],Len}| per_enc_length(Bin, 8, Len, Constraint, Aligned, 'OCTET STRING')]. per_enc_restricted_string(Val0, {M,F}, Aligned) -> {B,[Val,Bin,Len]} = mk_vars(Val0, [bin,len]), B ++ [{call,M,F,[Val],Bin}, {call,erlang,byte_size,[Bin],Len}| per_enc_length(Bin, 8, Len, Aligned)]. per_enc_small_number(Val, Aligned) -> build_cond([[{lt,Val,64},{put_bits,Val,7,[1]}], ['_',{put_bits,1,1,[1]}| per_enc_unsigned(Val, Aligned)]]). per_enc_extension_bit(Val0, _Aligned) -> {B,[Val]} = mk_vars(Val0, []), B++build_cond([[{eq,Val,[]},{put_bits,0,1,[1]}], ['_',{put_bits,1,1,[1]}]]). per_enc_extensions(Val0, Pos0, NumBits, Aligned) when NumBits > 0 -> Pos = Pos0 + 1, {B,[Val,Bitmap]} = mk_vars(Val0, [bitmap]), Length = per_enc_small_length(NumBits, Aligned), PutBits = case NumBits of 1 -> [{put_bits,1,1,[1]}]; _ -> [{put_bits,Bitmap,NumBits,[1]}] end, B++[{call,per_common,extension_bitmap,[Val,Pos,Pos+NumBits],Bitmap}, {list,[{'cond',[[{eq,Bitmap,0}], ['_'|Length ++ PutBits]]}], {var,"Extensions"}}]. per_enc_optional(Val0, {Pos,DefVals}, _Aligned) when is_integer(Pos), is_list(DefVals) -> {B,Val} = enc_element(Pos, Val0), Zero = {put_bits,0,1,[1]}, One = {put_bits,1,1,[1]}, B++[{'cond', [[{eq,Val,DefVal},Zero] || DefVal <- DefVals] ++ [['_',One]]}]; per_enc_optional(Val0, {Pos,{call,M,F,A}}, _Aligned) when is_integer(Pos) -> {B,Val} = enc_element(Pos, Val0), {[],[[],Tmp]} = mk_vars([], [tmp]), Zero = {put_bits,0,1,[1]}, One = {put_bits,1,1,[1]}, B++[{call,M,F,[Val|A],Tmp}, {'cond', [[{eq,Tmp,true},Zero],['_',One]]}]; per_enc_optional(Val0, Pos, _Aligned) when is_integer(Pos) -> {B,Val} = enc_element(Pos, Val0), Zero = {put_bits,0,1,[1]}, One = {put_bits,1,1,[1]}, B++[{'cond',[[{eq,Val,asn1_NOVALUE},Zero], ['_',One]]}]. per_enc_sof(Val0, Constraint, ElementVar, ElementImm, Aligned) -> {B,[Val,Len]} = mk_vars(Val0, [len]), SzConstraint = effective_constraint(bitstring, Constraint), LenImm = enc_length(Len, SzConstraint, Aligned), Lc0 = [{lc,ElementImm,{var,atom_to_list(ElementVar)},Val}], Lc = opt_lc(Lc0, LenImm), PreBlock = B ++ [{call,erlang,length,[Val],Len}], case LenImm of [{'cond',[[C|Action]]}] -> PreBlock ++ [{'cond',[[C|Action++Lc]]}]; [{sub,_,_,_}=Sub,{'cond',[[C|Action]]}] -> PreBlock ++ [Sub,{'cond',[[C|Action++Lc]]}]; EncLen -> PreBlock ++ EncLen ++ Lc end. enc_absent(Val0, {call,M,F,A}, Body) -> {B,[Var,Tmp]} = mk_vars(Val0, [tmp]), B++[{call,M,F,[Var|A],Tmp}, {'cond', [[{eq,Tmp,true}],['_'|Body]]}]; enc_absent(Val0, AbsVals, Body) when is_list(AbsVals) -> {B,[Var]} = mk_vars(Val0, []), Cs = [[{eq,Var,Aval}] || Aval <- AbsVals] ++ [['_'|Body]], B++build_cond(Cs). enc_append([[]|T]) -> enc_append(T); enc_append([[{put_bits,_,_,_}|_]=Pb|[Imm|T]=T0]) -> case opt_choice(Pb++Imm) of [{put_bits,_,_,_}|_] -> [{block,Pb}|enc_append(T0)]; Opt -> enc_append([Opt|T]) end; enc_append([Imm0|[Imm1|T]=T0]) -> try combine_imms(Imm0, Imm1) of Imm -> enc_append([Imm|T]) catch throw:impossible -> [{block,Imm0}|enc_append(T0)] end; enc_append([H|T]) -> [{block,H}|enc_append(T)]; enc_append([]) -> []. enc_element(N, Val0) -> {[],[Val,Dst]} = mk_vars(Val0, [element]), {[{call,erlang,element,[N,Val],Dst}],Dst}. enc_cg(Imm0, false) -> Imm1 = enc_cse(Imm0), Imm2 = enc_pre_cg(Imm1), Imm = enc_opt(Imm2), enc_cg(Imm); enc_cg(Imm0, true) -> Imm1 = enc_cse(Imm0), Imm2 = enc_hoist_align(Imm1), Imm3 = enc_opt_al(Imm2), Imm4 = per_fixup(Imm3), Imm5 = enc_pre_cg(Imm4), Imm = enc_opt(Imm5), enc_cg(Imm). %%% %%% Local functions. %%% %% is_aligned(StringType, LowerBound, UpperBound) -> boolean() %% StringType = 'OCTET STRING' | 'BIT STRING' | k_m_string %% LowerBound = UpperBound = number of bits %% Determine whether a string should be aligned in PER. is_aligned(T, Lb, Ub) when T =:= 'OCTET STRING'; T =:= 'BIT STRING' -> %% OCTET STRINGs and BIT STRINGs are aligned to a byte boundary %% unless the size is fixed and less than or equal to 16 bits. Lb =/= Ub orelse Lb > 16; is_aligned(k_m_string, _Lb, Ub) -> %% 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 %% be aligned. Ub >= 16. %%% %%% Generating the intermediate format format for decoding. %%% dec_string(Sv, U, Aligned0, T) when is_integer(Sv) -> Bits = U*Sv, Aligned = Aligned0 andalso is_aligned(T, Bits, Bits), {get_bits,Sv,[U,binary,{align,Aligned}]}; dec_string({{Sv,Sv},[]}, U, Aligned, T) -> bit_case(dec_string(Sv, U, Aligned, T), dec_string(no, U, Aligned, T)); dec_string({{_,_}=C,[]}, U, Aligned, T) -> bit_case(dec_string(C, U, Aligned, T), dec_string(no, U, Aligned, T)); dec_string({Lb,Ub}, U, Aligned0, T) -> Len = per_dec_constrained(Lb, Ub, Aligned0), Aligned = Aligned0 andalso is_aligned(T, Lb*U, Ub*U), {get_bits,Len,[U,binary,{align,Aligned}]}; dec_string(_, U, Aligned, _T) -> Al = [{align,Aligned}], DecRest = fun(V, Buf) -> asn1ct_func:call(per_common, decode_fragmented, [V,Buf,U]) end, {'case',[{test,{get_bits,1,[1|Al]},0, {value,{get_bits, {get_bits,7,[1]}, [U,binary]}}}, {test,{get_bits,1,[1|Al]},1, {test,{get_bits,1,[1]},0, {value,{get_bits, {get_bits,14,[1]}, [U,binary]}}}}, {test,{get_bits,1,[1|Al]},1, {test,{get_bits,1,[1]},1, {value,{call,DecRest,{get_bits,6,[1]}}}}}]}. per_dec_enumerated_fix_list([{V,_}|T], Tail, N) -> [{N,V}|per_dec_enumerated_fix_list(T, Tail, N+1)]; per_dec_enumerated_fix_list([], Tail, _) -> Tail. per_dec_integer_1([{'SingleValue',Value}], _Aligned) -> {value,Value}; per_dec_integer_1([{'ValueRange',{Lb,'MAX'}}], Aligned) when is_integer(Lb) -> per_decode_semi_constrained(Lb, Aligned); per_dec_integer_1([{'ValueRange',{Lb,Ub}}], Aligned) when is_integer(Lb), is_integer(Ub) -> per_dec_constrained(Lb, Ub, Aligned); per_dec_integer_1([{{_,_}=Constr0,_}], Aligned) -> Constr = effective_constraint(integer, [Constr0]), bit_case(per_dec_integer(Constr, Aligned), per_dec_unconstrained(Aligned)); per_dec_integer_1([], Aligned) -> per_dec_unconstrained(Aligned). per_dec_unconstrained(Aligned) -> {get_bits,decode_unconstrained_length(false, Aligned),[8,signed]}. per_dec_constrained(Lb, Ub, false) -> Range = Ub - Lb + 1, Get = {get_bits,uper_num_bits(Range),[1]}, add_lb(Lb, Get); per_dec_constrained(Lb, Ub, true) -> Range = Ub - Lb + 1, Get = if Range =< 255 -> {get_bits,per_num_bits(Range),[1,unsigned]}; Range == 256 -> {get_bits,1,[8,unsigned,{align,true}]}; Range =< 65536 -> {get_bits,2,[8,unsigned,{align,true}]}; true -> RangeOctLen = byte_size(binary:encode_unsigned(Range - 1)), {get_bits,per_dec_length({1,RangeOctLen}, false, true), [8,unsigned,{align,true}]} end, add_lb(Lb, Get). add_lb(0, Get) -> Get; add_lb(Lb, Get) -> {add,Get,Lb}. per_dec_normally_small_number(Aligned) -> Small = {get_bits,6,[1]}, Unlimited = per_decode_semi_constrained(0, Aligned), bit_case(Small, Unlimited). per_dec_normally_small_length(Aligned) -> Small = {add,{get_bits,6,[1]},1}, Unlimited = decode_unconstrained_length(false, Aligned), bit_case(Small, Unlimited). per_decode_semi_constrained(Lb, Aligned) -> add_lb(Lb, {get_bits,decode_unconstrained_length(false, Aligned),[8]}). bit_case(Base, Ext) -> {'case',[{test,{get_bits,1,[1]},0,Base}, {test,{get_bits,1,[1]},1,Ext}]}. decode_unconstrained_length(AllowZero, Aligned) -> Al = [{align,Aligned}], Zero = case AllowZero of false -> [non_zero]; true -> [] end, {'case',[{test,{get_bits,1,[1|Al]},0, {value,{get_bits,7,[1|Zero]}}}, {test,{get_bits,1,[1|Al]},1, {test,{get_bits,1,[1]},0, {value,{get_bits,14,[1|Zero]}}}}]}. uper_num_bits(N) -> uper_num_bits(N, 1, 0). uper_num_bits(N, T, B) when N =< T -> B; uper_num_bits(N, T, B) -> uper_num_bits(N, T bsl 1, B+1). per_num_bits(2) -> 1; per_num_bits(N) when N =< 4 -> 2; per_num_bits(N) when N =< 8 -> 3; per_num_bits(N) when N =< 16 -> 4; per_num_bits(N) when N =< 32 -> 5; 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 not lists:member(signed, Flags) andalso is_integer(Bits0) of true -> Bits = U*Bits0, {0,(1 bsl Bits) - 1}; 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) -> case get_constraint(Constraint, 'PermittedAlphabet') of {'SingleValue',Sv} -> charbits(length(Sv), Aligned); no -> case StringType of 'IA5String' -> charbits(128, Aligned); 'VisibleString' -> charbits(95, Aligned); 'PrintableString' -> charbits(74, Aligned); 'NumericString' -> charbits(11, Aligned); 'UniversalString' -> 32; 'BMPString' -> 16 end end. charbits(NumChars, false) -> uper_num_bits(NumChars); charbits(NumChars, true) -> 1 bsl uper_num_bits(uper_num_bits(NumChars)). convert_string(8, notab, Imm) -> {convert,binary_to_list,Imm}; convert_string(NumBits, notab, Imm) when NumBits < 8 -> Dec = fun(V, Buf) -> emit(["{",{call,per_common,decode_chars, [V,NumBits]},com,Buf,"}"]) end, {call,Dec,Imm}; convert_string(NumBits, notab, Imm) when NumBits =:= 16 -> Dec = fun(V, Buf) -> emit(["{",{call,per_common,decode_chars_16bit, [V]},com,Buf,"}"]) end, {call,Dec,Imm}; convert_string(NumBits, notab, Imm) -> Dec = fun(V, Buf) -> emit(["{",{call,per_common,decode_big_chars, [V,NumBits]},com,Buf,"}"]) end, {call,Dec,Imm}; convert_string(NumBits, Chars, Imm) -> Dec = fun(V, Buf) -> emit(["{",{call,per_common,decode_chars, [V,NumBits,{asis,Chars}]},com,Buf,"}"]) end, {call,Dec,Imm}. char_tab(C, StringType, NumBits) -> case get_constraint(C, 'PermittedAlphabet') of {'SingleValue',Sv} -> char_tab_1(Sv, NumBits); no -> case StringType of 'IA5String' -> notab; 'VisibleString' -> notab; 'PrintableString' -> Chars = " '()+,-./0123456789:=?" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz", char_tab_1(Chars, NumBits); 'NumericString' -> char_tab_1(" 0123456789", NumBits); 'UniversalString' -> notab; 'BMPString' -> notab end end. char_tab_1(Chars, NumBits) -> Max = lists:max(Chars), BitValMax = (1 bsl NumBits) - 1, if Max =< BitValMax -> notab; true -> list_to_tuple(lists:sort(Chars)) end. %%% %%% Remove unnecessary aligning to octet boundaries. %%% opt_al({get_bits,E0,Opts0}, A0) -> {E,A1} = opt_al(E0, A0), Opts = opt_al_1(A1, Opts0), A = update_al(A1, E, Opts), {{get_bits,E,Opts},A}; opt_al({call,Fun,E0}, A0) -> {E,A} = opt_al(E0, A0), {{call,Fun,E},A}; opt_al({convert,Op,E0}, A0) -> {E,A} = opt_al(E0, A0), {{convert,Op,E},A}; opt_al({value,V}=Term, A) when is_integer(V); is_atom(V) -> {Term,A}; opt_al({value,E0}, A0) -> {E,A} = opt_al(E0, A0), {{value,E},A}; opt_al({add,E0,I}, A0) when is_integer(I) -> {E,A} = opt_al(E0, A0), {{add,E,I},A}; opt_al({test,E0,V,B0}, A0) -> {E,A1} = opt_al(E0, A0), {B,A2} = opt_al(B0, A1), {{test,E,V,B},A2}; opt_al({'case',Cs0}, A0) -> {Cs,A} = opt_al_cs(Cs0, A0), {{'case',Cs},A}; opt_al({map,E0,Cs}, A0) -> {E,A} = opt_al(E0, A0), {{map,E,Cs},A}; opt_al(I, A) when is_integer(I) -> {I,A}. opt_al_cs([C0|Cs0], A0) -> {C,A1} = opt_al(C0, A0), {Cs,A2} = opt_al_cs(Cs0, A0), {[C|Cs],merge_al(A1, A2)}; opt_al_cs([], _) -> {[],none}. merge_al(unknown, _) -> unknown; merge_al(Other, none) -> Other; merge_al(_, unknown) -> unknown; merge_al(I0, I1) -> case {I0 rem 8,I1 rem 8} of {I,I} -> I; {_,_} -> unknown end. opt_al_1(unknown, Opts) -> Opts; opt_al_1(A, Opts0) -> case alignment(Opts0) of none -> Opts0; full -> case A rem 8 of 0 -> %% Already in alignment. proplists:delete(align, Opts0); Bits -> %% Cheaper alignment with a constant padding. Opts1 = proplists:delete(align, Opts0), [{align,8-Bits }|Opts1] end; A -> %Assertion. Opts0 end. update_al(A0, E, Opts) -> A = case alignment(Opts) of none -> A0; full -> 0; Bits when is_integer(A0) -> 0 = (A0 + Bits) rem 8; %Assertion. _ -> 0 end, [U] = [U || U <- Opts, is_integer(U)], if U rem 8 =:= 0 -> A; is_integer(A), is_integer(E) -> A + U*E; true -> unknown end. %%% %%% Flatten the intermediate format and assign temporaries. %%% flatten({get_bits,I,U}, Buf0, St0) when is_integer(I) -> {Dst,St} = new_var_pair(St0), Gb = {get_bits,{I,Buf0},U,Dst}, flatten_align(Gb, [], St); flatten({get_bits,E0,U}, Buf0, St0) -> {E,Pre,St1} = flatten(E0, Buf0, St0), {Dst,St2} = new_var_pair(St1), Gb = {get_bits,E,U,Dst}, flatten_align(Gb, Pre, St2); flatten({test,{get_bits,I,U},V,E0}, Buf0, St0) when is_integer(I) -> {DstBuf0,St1} = new_var("Buf", St0), Gb = {get_bits,{I,Buf0},U,{V,DstBuf0}}, {{_Dst,DstBuf},Pre0,St2} = flatten_align(Gb, [], St1), {E,Pre1,St3} = flatten(E0, DstBuf, St2), {E,Pre0++Pre1,St3}; flatten({add,E0,I}, Buf0, St0) -> {{Src,Buf},Pre,St1} = flatten(E0, Buf0, St0), {Dst,St} = new_var("Add", St1), {{Dst,Buf},Pre++[{add,Src,I,Dst}],St}; flatten({'case',Cs0}, Buf0, St0) -> {Dst,St1} = new_var_pair(St0), {Cs1,St} = flatten_cs(Cs0, Buf0, St1), {Al,Cs2} = flatten_hoist_align(Cs1), {Dst,Al++[{'case',Buf0,Cs2,Dst}],St}; flatten({map,E0,Cs0}, Buf0, St0) -> {{E,DstBuf},Pre,St1} = flatten(E0, Buf0, St0), {Dst,St2} = new_var("Int", St1), Cs = flatten_map_cs(Cs0, E), {{Dst,DstBuf},Pre++[{'map',E,Cs,{Dst,DstBuf}}],St2}; flatten({value,V}, Buf0, St0) when is_atom(V) -> {{"'"++atom_to_list(V)++"'",Buf0},[],St0}; flatten({value,V0}, Buf0, St0) when is_integer(V0) -> {{V0,Buf0},[],St0}; flatten({value,V0}, Buf0, St0) -> flatten(V0, Buf0, St0); flatten({convert,Op,E0}, Buf0, St0) -> {{E,Buf},Pre,St1} = flatten(E0, Buf0, St0), {Dst,St2} = new_var("Conv", St1), {{Dst,Buf},Pre++[{convert,Op,E,Dst}],St2}; flatten({call,Fun,E0}, Buf0, St0) -> {Src,Pre,St1} = flatten(E0, Buf0, St0), {Dst,St2} = new_var_pair(St1), {Dst,Pre++[{call,Fun,Src,Dst}],St2}. flatten_cs([C0|Cs0], Buf, St0) -> {C,Pre,St1} = flatten(C0, Buf, St0), {Cs,St2} = flatten_cs(Cs0, Buf, St0), St3 = St2#st{var=max(St1#st.var, St2#st.var)}, {[Pre++[{return,C}]|Cs],St3}; flatten_cs([], _, St) -> {[],St}. flatten_map_cs(Cs, Var) -> flatten_map_cs_1(Cs, {Var,Cs}). flatten_map_cs_1([{K,V}|Cs], DefData) -> [{{asis,K},{asis,V}}|flatten_map_cs_1(Cs, DefData)]; flatten_map_cs_1([integer_default], {Int,_}) -> [{'_',Int}]; flatten_map_cs_1([enum_default], {Int,_}) -> [{'_',["{asn1_enum,",Int,"}"]}]; flatten_map_cs_1([enum_error], {Var,Cs}) -> Vs = [V || {_,V} <- Cs], [{'_',["exit({error,{asn1,{decode_enumerated,{",Var,",", {asis,Vs},"}}}})"]}]; flatten_map_cs_1([], _) -> []. flatten_hoist_align([[{align_bits,_,_}=Ab|T]|Cs]) -> flatten_hoist_align_1(Cs, Ab, [T]); flatten_hoist_align(Cs) -> {[],Cs}. flatten_hoist_align_1([[Ab|T]|Cs], Ab, Acc) -> flatten_hoist_align_1(Cs, Ab, [T|Acc]); flatten_hoist_align_1([], Ab, Acc) -> {[Ab],lists:reverse(Acc)}. flatten_align({get_bits,{SrcBits,SrcBuf},U,Dst}=Gb0, Pre, St0) -> case alignment(U) of none -> flatten_align_1(U, Dst, Pre++[Gb0], St0); full -> {PadBits,St1} = new_var("Pad", St0), {DstBuf,St2} = new_var("Buf", St1), Ab = {align_bits,SrcBuf,PadBits}, Agb = {get_bits,{PadBits,SrcBuf},[1],{'_',DstBuf}}, Gb = {get_bits,{SrcBits,DstBuf},U,Dst}, flatten_align_1(U, Dst, Pre++[Ab,Agb,Gb], St2); PadBits when is_integer(PadBits), PadBits > 0 -> {DstBuf,St1} = new_var("Buf", St0), Agb = {get_bits,{PadBits,SrcBuf},[1],{'_',DstBuf}}, Gb = {get_bits,{SrcBits,DstBuf},U,Dst}, flatten_align_1(U, Dst, Pre++[Agb,Gb], St1) end. flatten_align_1(U, {D,_}=Dst, Pre, St) -> case is_non_zero(U) of false -> {Dst,Pre,St}; true -> {Dst,Pre++[{non_zero,D}],St} end. new_var_pair(St0) -> {Var,St1} = new_var("V", St0), {Buf,St2} = new_var("Buf", St1), {{Var,Buf},St2}. new_var(Tag, #st{base=VarBase,var=N}=St) -> {VarBase++Tag++integer_to_list(N),St#st{var=N+1}}. alignment([{align,false}|_]) -> none; alignment([{align,true}|_]) -> full; alignment([{align,Bits}|_]) -> Bits; alignment([_|T]) -> alignment(T); alignment([]) -> none. is_non_zero(Fl) -> lists:member(non_zero, Fl). %%% %%% Generate Erlang code from the flattened intermediate format. %%% dcg_list_outside([{align_bits,Buf,SzVar}|T]) -> emit([SzVar," = bit_size(",Buf,") band 7"]), iter_dcg_list_outside(T); dcg_list_outside([{'case',Buf,Cs,Dst}|T]) -> dcg_case(Buf, Cs, Dst), iter_dcg_list_outside(T); dcg_list_outside([{'map',Val,Cs,Dst}|T]) -> dcg_map(Val, Cs, Dst), iter_dcg_list_outside(T); dcg_list_outside([{add,S1,S2,Dst}|T]) -> emit([Dst," = ",S1," + ",S2]), iter_dcg_list_outside(T); dcg_list_outside([{return,{V,Buf}}|T]) -> emit(["{",V,",",Buf,"}"]), iter_dcg_list_outside(T); dcg_list_outside([{call,Fun,{V,Buf},{Dst,DstBuf}}|T]) -> emit(["{",Dst,",",DstBuf,"} = "]), Fun(V, Buf), iter_dcg_list_outside(T); dcg_list_outside([{convert,{M,F},V,Dst}|T]) -> emit([Dst," = ",{asis,M},":",{asis,F},"(",V,")"]), iter_dcg_list_outside(T); dcg_list_outside([{convert,Op,V,Dst}|T]) -> emit([Dst," = ",Op,"(",V,")"]), iter_dcg_list_outside(T); dcg_list_outside([{get_bits,{_,Buf0},_,_}|_]=L0) -> emit("<<"), {L,Buf} = dcg_list_inside(L0, buf), emit([Buf,"/bitstring>> = ",Buf0]), iter_dcg_list_outside(L); dcg_list_outside([]) -> emit("ignore"), ok. iter_dcg_list_outside([_|_]=T) -> emit([",",nl]), dcg_list_outside(T); iter_dcg_list_outside([]) -> ok. dcg_case(Buf, Cs, {Dst,DstBuf}) -> emit(["{",Dst,",",DstBuf,"} = case ",Buf," of",nl]), dcg_case_cs(Cs), emit("end"). dcg_case_cs([C|Cs]) -> emit("<<"), {T0,DstBuf} = dcg_list_inside(C, buf), emit([DstBuf,"/bitstring>>"]), T1 = dcg_guard(T0), dcg_list_outside(T1), case Cs of [] -> emit([nl]); [_|_] -> emit([";",nl]) end, dcg_case_cs(Cs); dcg_case_cs([]) -> ok. dcg_guard([{non_zero,Src}|T]) -> emit([" when ",Src," =/= 0 ->",nl]), T; dcg_guard(T) -> emit([" ->",nl]), T. dcg_map(Val, Cs, {Dst,_}) -> emit([Dst," = case ",Val," of",nl]), dcg_map_cs(Cs), emit("end"). dcg_map_cs([{K,V}]) -> emit([K," -> ",V,nl]); dcg_map_cs([{K,V}|Cs]) -> emit([K," -> ",V,";",nl]), dcg_map_cs(Cs). dcg_list_inside([{get_bits,{Sz,_},Fl0,{Dst,DstBuf}}|T], _) -> Fl = bit_flags(Fl0, []), emit([mk_dest(Dst),":",Sz,Fl,","]), dcg_list_inside(T, DstBuf); dcg_list_inside(L, Dst) -> {L,Dst}. bit_flags([{align,_}|T], Acc) -> bit_flags(T, Acc); bit_flags([non_zero|T], Acc) -> bit_flags(T, Acc); bit_flags([U|T], Acc) when is_integer(U) -> bit_flags(T, ["unit:"++integer_to_list(U)|Acc]); bit_flags([H|T], Acc) -> bit_flags(T, [atom_to_list(H)|Acc]); bit_flags([], []) -> ""; bit_flags([], Acc) -> case "/" ++ bit_flags_1(Acc, "") of "/unit:1" -> []; Opts -> Opts end. bit_flags_1([H|T], Sep) -> Sep ++ H ++ bit_flags_1(T, "-"); bit_flags_1([], _) -> []. mk_dest(I) when is_integer(I) -> integer_to_list(I); mk_dest(S) -> S. %%% %%% Constructing the intermediate format for encoding. %%% split_off_nonbuilding(Imm) -> lists:splitwith(fun is_nonbuilding/1, Imm). is_nonbuilding({assign,_,_}) -> true; is_nonbuilding({call,_,_,_,_}) -> true; is_nonbuilding({lc,_,_,_,_}) -> true; is_nonbuilding({set,_,_}) -> true; is_nonbuilding({list,_,_}) -> true; is_nonbuilding({sub,_,_,_}) -> true; is_nonbuilding({'try',_,_,_,_}) -> true; is_nonbuilding(_) -> false. mk_vars(Input0, Temps) -> asn1ct_name:new(enc), Curr = asn1ct_name:curr(enc), [H|T] = atom_to_list(Curr), Base = [H - ($a - $A)|T ++ "@"], case Input0 of {var,Name} when is_list(Name) -> {[],[Input0|mk_vars_1(Base, Temps)]}; [] -> {[],[Input0|mk_vars_1(Base, Temps)]}; _ when is_integer(Input0) -> {[],[Input0|mk_vars_1(Base, Temps)]} end. mk_vars_1(Base, Vars) -> [mk_var(Base, V) || V <- Vars]. mk_var(Base, V) -> {var,Base ++ atom_to_list(V)}. per_enc_integer_1(Val, [], Aligned) -> [{'cond',[['_'|per_enc_unconstrained(Val, Aligned)]]}]; per_enc_integer_1(Val, [{{'SingleValue',[_|_]=Svs}=Constr,[]}], Aligned) -> %% An extensible constraint such as (1|17, ...). %% %% A subtle detail is that the extension root as described in the %% ASN.1 spec should be used to determine whether a particular value %% belongs to the extension root (as opposed to the effective %% constraint, which will be used for the actual encoding). %% %% So for the example above, only the integers 1 and 17 should be %% encoded as root values (extension bit = 0). [{'ValueRange',{Lb,Ub}}] = effective_constraint(integer, [Constr]), Root = [begin {[],_,Put} = per_enc_constrained(Sv, Lb, Ub, Aligned), [{eq,Val,Sv},{put_bits,0,1,[1]}|Put] end || Sv <- Svs], Cs = Root ++ [['_',{put_bits,1,1,[1]}| per_enc_unconstrained(Val, Aligned)]], build_cond(Cs); per_enc_integer_1(Val0, [{{_,_}=Constr,[]}], Aligned) -> {Prefix,Check,Action} = per_enc_integer_2(Val0, Constr, Aligned), Prefix++build_cond([[Check,{put_bits,0,1,[1]}|Action], ['_',{put_bits,1,1,[1]}| per_enc_unconstrained(Val0, Aligned)]]); per_enc_integer_1(Val0, [Constr], Aligned) -> {Prefix,Check,Action} = per_enc_integer_2(Val0, Constr, Aligned), Prefix++build_cond([[Check|Action], ['_',{error,Val0}]]). per_enc_integer_2(Val, {'SingleValue',Sv}, Aligned) when is_integer(Sv) -> per_enc_constrained(Val, Sv, Sv, Aligned); per_enc_integer_2(Val0, {'ValueRange',{Lb,'MAX'}}, Aligned) when is_integer(Lb) -> {Prefix,Val} = sub_lb(Val0, Lb), {Prefix,{ge,Val,0},per_enc_unsigned(Val, Aligned)}; per_enc_integer_2(Val, {'ValueRange',{Lb,Ub}}, Aligned) when is_integer(Lb), is_integer(Ub) -> per_enc_constrained(Val, Lb, Ub, Aligned). per_enc_constrained(Val, Sv, Sv, _Aligned) -> {[],{eq,Val,Sv},[]}; per_enc_constrained(Val0, Lb, Ub, false) -> {Prefix,Val} = sub_lb(Val0, Lb), Range = Ub - Lb + 1, NumBits = uper_num_bits(Range), Check = {ult,Val,Range}, Put = [{put_bits,Val,NumBits,[1]}], {Prefix,Check,Put}; per_enc_constrained(Val0, Lb, Ub, true) -> {Prefix,Val} = sub_lb(Val0, Lb), Range = Ub - Lb + 1, if Range < 256 -> NumBits = per_num_bits(Range), Check = {ult,Val,Range}, Put = [{put_bits,Val,NumBits,[1]}], {Prefix,Check,Put}; Range =:= 256 -> NumBits = 8, Check = {ult,Val,Range}, Put = [{put_bits,Val,NumBits,[1,align]}], {Prefix,Check,Put}; Range =< 65536 -> Check = {ult,Val,Range}, Put = [{put_bits,Val,16,[1,align]}], {Prefix,Check,Put}; true -> {var,VarBase} = Val, Bin = {var,VarBase++"@bin"}, BinSize0 = {var,VarBase++"@bin_size0"}, BinSize = {var,VarBase++"@bin_size"}, Check = {ult,Val,Range}, RangeOctsLen = byte_size(binary:encode_unsigned(Range - 1)), BitsNeeded = per_num_bits(RangeOctsLen), Enc = [{call,binary,encode_unsigned,[Val],Bin}, {call,erlang,byte_size,[Bin],BinSize0}, {sub,BinSize0,1,BinSize}, {'cond',[['_', {put_bits,BinSize,BitsNeeded,[1]}, {put_bits,Bin,binary,[8,align]}]]}], {Prefix,Check,Enc} end. per_enc_unconstrained(Val, Aligned) -> case Aligned of false -> []; true -> [{put_bits,0,0,[1,align]}] end ++ [{call,per_common,encode_unconstrained_number,[Val]}]. per_enc_unsigned(Val, Aligned) -> case is_integer(Val) of false -> {var,VarBase} = Val, Bin = {var,VarBase++"@bin"}, BinSize = {var,VarBase++"@bin_size"}, [{call,binary,encode_unsigned,[Val],Bin}, {call,erlang,byte_size,[Bin],BinSize}| per_enc_length(Bin, 8, BinSize, Aligned)]; true -> Bin = binary:encode_unsigned(Val), Len = byte_size(Bin), per_enc_length(Bin, 8, Len, Aligned) end. %% Encode a length field without any constraint. per_enc_length(Bin, Unit, Len, Aligned) -> U = unit(1, Aligned), PutBits = put_bits_binary(Bin, Unit, Aligned), EncFragmented = {call,per_common,encode_fragmented,[Bin,Unit]}, Al = case Aligned of false -> []; true -> [{put_bits,0,0,[1,align]}] end, build_cond([[{lt,Len,128}, {put_bits,Len,8,U},PutBits], [{lt,Len,16384}, {put_bits,2,2,U},{put_bits,Len,14,[1]},PutBits], ['_'|Al++[EncFragmented]]]). per_enc_length(Bin, Unit, Len, no, Aligned, _Type) -> per_enc_length(Bin, Unit, Len, Aligned); per_enc_length(Bin, Unit, Len, {{Lb,Ub},[]}, Aligned, Type) -> {Prefix,Check,PutLen} = per_enc_constrained(Len, Lb, Ub, Aligned), NoExt = {put_bits,0,1,[1]}, U = unit(Unit, Aligned, Type, Lb*Unit, Ub*Unit), PutBits = [{put_bits,Bin,binary,U}], [{'cond',ExtConds0}] = per_enc_length(Bin, Unit, Len, Aligned), Ext = {put_bits,1,1,[1]}, ExtConds = prepend_to_cond(ExtConds0, Ext), build_length_cond(Prefix, [[Check,NoExt|PutLen++PutBits]|ExtConds]); per_enc_length(Bin, Unit, Len, {Lb,Ub}, Aligned, Type) when is_integer(Lb) -> {Prefix,Check,PutLen} = per_enc_constrained(Len, Lb, Ub, Aligned), U = unit(Unit, Aligned, Type, Lb*Unit, Ub*Unit), PutBits = [{put_bits,Bin,binary,U}], build_length_cond(Prefix, [[Check|PutLen++PutBits]]); per_enc_length(Bin, Unit0, Len, Sv, Aligned, Type) when is_integer(Sv) -> NumBits = Sv*Unit0, Unit = case NumBits rem 8 of 0 -> %% Help out the alignment optimizer. 8; _ -> Unit0 end, U = unit(Unit, Aligned, Type, NumBits, NumBits), Pb = {put_bits,Bin,binary,U}, [{'cond',[[{eq,Len,Sv},Pb]]}]. enc_length(Len, no, Aligned) -> U = unit(1, Aligned), build_cond([[{lt,Len,128}, {put_bits,Len,8,U}], [{lt,Len,16384}, {put_bits,2,2,U},{put_bits,Len,14,[1]}]]); enc_length(Len, {{Lb,Ub},[]}, Aligned) -> {Prefix,Check,PutLen} = per_enc_constrained(Len, Lb, Ub, Aligned), NoExt = {put_bits,0,1,[1]}, [{'cond',ExtConds0}] = enc_length(Len, no, Aligned), Ext = {put_bits,1,1,[1]}, ExtConds = prepend_to_cond(ExtConds0, Ext), build_length_cond(Prefix, [[Check,NoExt|PutLen]|ExtConds]); enc_length(Len, {Lb,Ub}, Aligned) when is_integer(Lb) -> {Prefix,Check,PutLen} = per_enc_constrained(Len, Lb, Ub, Aligned), build_length_cond(Prefix, [[Check|PutLen]]); enc_length(Len, Sv, _Aligned) when is_integer(Sv) -> [{'cond',[[{eq,Len,Sv}]]}]. put_bits_binary(Bin, _Unit, Aligned) when is_binary(Bin) -> Sz = byte_size(Bin), <<Int:Sz/unit:8>> = Bin, {put_bits,Int,8*Sz,unit(1, Aligned)}; put_bits_binary(Bin, Unit, Aligned) -> {put_bits,Bin,binary,unit(Unit, Aligned)}. sub_lb(Val, 0) -> {[],Val}; sub_lb({var,Var}=Val0, Lb) -> Val = {var,Var++"@sub"}, {[{sub,Val0,Lb,Val}],Val}; sub_lb(Val, Lb) when is_integer(Val) -> {[],Val-Lb}. build_length_cond([{sub,Var0,Base,Var}]=Prefix, Cs) -> %% Non-zero lower bound, such as: SIZE (50..200, ...) Prefix++[{'cond',opt_length_nzlb(Cs, {Var0,Var,Base}, 0)}]; build_length_cond([], Cs) -> %% Zero lower bound, such as: SIZE (0..200, ...) [{'cond',opt_length_zlb(Cs, 0)}]. opt_length_zlb([[{ult,Var,Val}|Actions]|T], Ub) -> %% Since the SIZE constraint is zero-based, Var %% must be greater than zero, and we can use %% the slightly cheaper signed less than operator. opt_length_zlb([[{lt,Var,Val}|Actions]|T], Ub); opt_length_zlb([[{lt,_,Val}|_]=H|T], Ub) -> if Val =< Ub -> %% A previous test has already matched. opt_length_zlb(T, Ub); true -> [H|opt_length_zlb(T, max(Ub, Val))] end; opt_length_zlb([H|T], Ub) -> [H|opt_length_zlb(T, Ub)]; opt_length_zlb([], _) -> []. opt_length_nzlb([[{ult,Var,Val}|_]=H|T], {_,Var,Base}=St, _Ub) -> [H|opt_length_nzlb(T, St, Base+Val)]; opt_length_nzlb([[{lt,Var0,Val}|_]=H|T], {Var0,_,_}=St, Ub) -> if Val =< Ub -> %% A previous test has already matched. opt_length_nzlb(T, St, Ub); true -> [H|opt_length_nzlb(T, St, Val)] end; opt_length_nzlb([H|T], St, Ub) -> [H|opt_length_nzlb(T, St, Ub)]; opt_length_nzlb([], _, _) -> []. build_cond(Conds0) -> case eval_cond(Conds0, gb_sets:empty()) of [['_'|Actions]] -> Actions; Conds -> [{'cond',Conds}] end. eval_cond([['_',{'cond',Cs}]], Seen) -> eval_cond(Cs, Seen); eval_cond([[Cond|Actions]=H|T], Seen0) -> case gb_sets:is_element(Cond, Seen0) of false -> Seen = gb_sets:insert(Cond, Seen0), case eval_cond_1(Cond) of false -> eval_cond(T, Seen); true -> [['_'|Actions]]; maybe -> [H|eval_cond(T, Seen)] end; true -> eval_cond(T, Seen0) end; eval_cond([], _) -> []. eval_cond_1({ult,I,N}) when is_integer(I), is_integer(N) -> 0 =< I andalso I < N; 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. prepend_to_cond([H|T], Code) -> [prepend_to_cond_1(H, Code)|prepend_to_cond(T, Code)]; prepend_to_cond([], _) -> []. prepend_to_cond_1([Check|T], Code) -> [Check,Code|T]. enc_char_tab(notab) -> notab; enc_char_tab(Tab0) -> 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)]; enc_char_tab_1([_|_]=T, H, I) -> [ill|enc_char_tab_1(T, H+1, I)]; enc_char_tab_1([], _, _) -> []. enumerated_constraint([_]) -> [{'SingleValue',0}]; enumerated_constraint(Root) -> [{'ValueRange',{0,length(Root)-1}}]. per_enc_enumerated_root(NNL, Prefix, Val, Constr, Aligned) -> per_enc_enumerated_root_1(NNL, Prefix, Val, Constr, Aligned, 0). per_enc_enumerated_root_1([{H,_}|T], Prefix, Val, Constr, Aligned, N) -> [[{eq,Val,H}|Prefix++per_enc_integer_1(N, Constr, Aligned)]| per_enc_enumerated_root_1(T, Prefix, Val, Constr, Aligned, N+1)]; per_enc_enumerated_root_1([], _, _, _, _, _) -> []. per_enc_enumerated_ext(NNL, Val, Aligned) -> per_enc_enumerated_ext_1(NNL, Val, Aligned, 0). per_enc_enumerated_ext_1([{H,_}|T], Val, Aligned, N) -> [[{eq,Val,H},{put_bits,1,1,[1]}|per_enc_small_number(N, Aligned)]| per_enc_enumerated_ext_1(T, Val, Aligned, N+1)]; per_enc_enumerated_ext_1([], _, _, _) -> []. per_enc_small_length(Val0, Aligned) -> {Sub,Val} = sub_lb(Val0, 1), U = unit(1, Aligned), Sub ++ build_cond([[{lt,Val,64},{put_bits,Val,7,[1]}], [{lt,Val0,128},{put_bits,1,1,[1]}, {put_bits,Val0,8,U}], ['_',{put_bits,1,1,[1]}, {put_bits,2,2,U},{put_bits,Val0,14,[1]}]]). constr_min_size(no) -> no; constr_min_size({{Lb,_},[]}) when is_integer(Lb) -> Lb; constr_min_size({Lb,_}) when is_integer(Lb) -> Lb; constr_min_size(Sv) when is_integer(Sv) -> Sv. enc_mod(false) -> uper; enc_mod(true) -> per. unit(U, false) -> [U]; unit(U, true) -> [U,align]. unit(U, Aligned, Type, Lb, Ub) -> case Aligned andalso is_aligned(Type, Lb, Ub) of true -> [U,align]; false -> [U] end. opt_choice(Imm) -> {Pb,T0} = lists:splitwith(fun({put_bits,V,_,_}) when is_integer(V) -> true; (_) -> false end, Imm), try {Prefix,T} = split_off_nonbuilding(T0), Prefix ++ opt_choice_1(T, Pb) catch throw:impossible -> Imm end. opt_choice_1([{'cond',Cs0}], Pb) -> case Cs0 of [[C|Act]] -> [{'cond',[[C|Pb++Act]]}]; [[C|Act],['_',{error,_}]=Error] -> [{'cond',[[C|Pb++Act],Error]}]; _ -> [{'cond',opt_choice_2(Cs0, Pb)}] end; opt_choice_1(_, _) -> throw(impossible). opt_choice_2([[C|[{put_bits,_,_,_}|_]=Act]|T], Pb) -> [[C|Pb++Act]|opt_choice_2(T, Pb)]; opt_choice_2([[_,{error,_}]=H|T], Pb) -> [H|opt_choice_2(T, Pb)]; opt_choice_2([_|_], _) -> throw(impossible); opt_choice_2([], _) -> []. %%% %%% Optimize list comprehensions (SEQUENCE OF/SET OF). %%% opt_lc([{lc,[{call,erlang,iolist_to_binary,[Var],Bin}, {call,erlang,byte_size,[Bin],LenVar}, {'cond',[[{eq,LenVar,Len},{put_bits,Bin,_,[_|Align]}]]}], Var,Val}]=Lc, LenImm) -> %% Given a sequence of a fixed length string, such as %% SEQUENCE OF OCTET STRING (SIZE (4)), attempt to rewrite to %% a list comprehension that just checks the size, followed by %% a conversion to binary: %% %% _ = [if length(Comp) =:= 4; byte_size(Comp) =:= 4 -> [] end || %% Comp <- Sof], %% [align|iolist_to_binary(Sof)] CheckImm = [{'cond',[[{eq,{expr,"length("++mk_val(Var)++")"},Len}], [{eq,{expr,"byte_size("++mk_val(Var)++")"},Len}]]}], Al = case Align of [] -> []; [align] -> [{put_bits,0,0,[1|Align]}] end, case Al =:= [] orelse is_end_aligned(LenImm) orelse lb_is_nonzero(LenImm) of false -> %% Not possible because an empty SEQUENCE OF would be %% improperly aligned. Example: %% %% SEQUENCE (SIZE (0..3)) OF ... Lc; true -> %% Examples: %% %% SEQUENCE (SIZE (1..4)) OF ... %% (OK because there must be at least one element) %% %% SEQUENCE OF ... %% (OK because the length field will force alignment) %% Al ++ [{lc,CheckImm,Var,Val,{var,"_"}}, {call,erlang,iolist_to_binary,[Val]}] end; opt_lc([{lc,ElementImm0,V,L}]=Lc, LenImm) -> %% Attempt to hoist the alignment, putting after the length %% and before the list comprehension: %% %% [Length, %% align, %% [Encode(Comp) || Comp <- Sof]] %% case enc_opt_al_1(ElementImm0, 0) of {ElementImm,0} -> case is_end_aligned(LenImm) orelse (is_beginning_aligned(ElementImm0) andalso lb_is_nonzero(LenImm)) of false -> %% Examples: %% %% SEQUENCE (SIZE (0..3)) OF OCTET STRING %% (An empty SEQUENCE OF would be improperly aligned) %% %% SEQUENCE (SIZE (1..3)) OF OCTET STRING (SIZE (0..4)) %% (There would be an improper alignment before the %% first element) Lc; true -> %% Examples: %% %% SEQUENCE OF INTEGER %% SEQUENCE (SIZE (1..4)) OF INTEGER %% SEQUENCE (SIZE (1..4)) OF INTEGER (0..256) [{put_bits,0,0,[1,align]},{lc,ElementImm,V,L}] end; _ -> %% Unknown alignment, no alignment, or not aligned at the end. %% Examples: %% %% SEQUENCE OF SomeConstructedType %% SEQUENCE OF INTEGER (0..15) Lc end. is_beginning_aligned([{'cond',Cs}]) -> lists:all(fun([_|Act]) -> is_beginning_aligned(Act) end, Cs); is_beginning_aligned([{error,_}|_]) -> true; is_beginning_aligned([{put_bits,_,_,U}|_]) -> case U of [_,align] -> true; [_] -> false end; is_beginning_aligned(Imm0) -> case split_off_nonbuilding(Imm0) of {[],_} -> false; {[_|_],Imm} -> is_beginning_aligned(Imm) end. is_end_aligned(Imm) -> case enc_opt_al_1(Imm, unknown) of {_,0} -> true; {_,_} -> false end. lb_is_nonzero([{sub,_,_,_}|_]) -> true; lb_is_nonzero(_) -> false. %%% %%% Attempt to combine two chunks of intermediate code. %%% combine_imms(ImmA0, ImmB0) -> {Prefix0,ImmA} = split_off_nonbuilding(ImmA0), {Prefix1,ImmB} = split_off_nonbuilding(ImmB0), Prefix = Prefix0 ++ Prefix1, Combined = do_combine(ImmA ++ ImmB, 3.0), Prefix ++ Combined. do_combine([{error,_}=Imm|_], _Budget) -> [Imm]; do_combine([{'cond',Cs0}|T], Budget0) -> Budget = debit(Budget0, num_clauses(Cs0, 0)), Cs = [[C|do_combine(Act++T, Budget)] || [C|Act] <- Cs0], [{'cond',Cs}]; do_combine([{put_bits,V,_,_}|_]=L, Budget) when is_integer(V) -> {Pb,T} = collect_put_bits(L), do_combine_put_bits(Pb, T,Budget); do_combine(_, _) -> throw(impossible). do_combine_put_bits(Pb, [], _Budget) -> Pb; do_combine_put_bits(Pb, [{'cond',Cs0}|T], Budget) -> Cs = [case Act of [{error,_}] -> [C|Act]; _ -> [C|do_combine(Pb++Act, Budget)] end || [C|Act] <- Cs0], do_combine([{'cond',Cs}|T], Budget); do_combine_put_bits(_, _, _) -> throw(impossible). debit(Budget0, Alternatives) -> case Budget0 - log2(Alternatives) of Budget when Budget > 0.0 -> Budget; _ -> throw(impossible) end. num_clauses([[_,{error,_}]|T], N) -> num_clauses(T, N); num_clauses([_|T], N) -> num_clauses(T, N+1); num_clauses([], N) -> N. log2(N) -> math:log(N) / math:log(2.0). collect_put_bits(Imm) -> lists:splitwith(fun({put_bits,V,_,_}) when is_integer(V) -> true; (_) -> false end, Imm). %%% %%% Simple common subexpression elimination to avoid fetching %%% the same element twice. %%% enc_cse([{call,erlang,element,Args,V}=H|T]) -> [H|enc_cse_1(T, Args, V)]; enc_cse(Imm) -> Imm. enc_cse_1([{call,erlang,element,Args,Dst}|T], Args, V) -> [{set,V,Dst}|enc_cse_1(T, Args, V)]; enc_cse_1([{block,Bl}|T], Args, V) -> [{block,enc_cse_1(Bl, Args, V)}|enc_cse_1(T, Args, V)]; enc_cse_1([H|T], Args, V) -> [H|enc_cse_1(T, Args, V)]; enc_cse_1([], _, _) -> []. %%% %%% Pre-process the intermediate code to simplify code generation. %%% enc_pre_cg(Imm) -> enc_pre_cg_1(Imm, outside_list, in_seq). enc_pre_cg_1([], _StL, _StB) -> nil; enc_pre_cg_1([H], StL, StB) -> enc_pre_cg_2(H, StL, StB); enc_pre_cg_1([H0|T0], StL, StB) -> case is_nonbuilding(H0) of true -> H = enc_pre_cg_nonbuilding(H0, StL), Seq = {seq,H,enc_pre_cg_1(T0, StL, in_seq)}, case StB of outside_seq -> {block,Seq}; in_seq -> Seq end; false -> H = enc_pre_cg_2(H0, in_head, outside_seq), T = enc_pre_cg_1(T0, in_tail, outside_seq), enc_make_cons(H, T) end. enc_pre_cg_2(align, StL, _StB) -> case StL of in_head -> align; in_tail -> {cons,align,nil} end; enc_pre_cg_2({apply,_,_}=Imm, _, _) -> Imm; enc_pre_cg_2({block,Bl0}, StL, StB) -> enc_pre_cg_1(Bl0, StL, StB); enc_pre_cg_2({call,_,_,_}=Imm, _, _) -> Imm; enc_pre_cg_2({call_gen,_,_,_,_,_}=Imm, _, _) -> Imm; enc_pre_cg_2({'cond',Cs0}, StL, _StB) -> Cs = [{C,enc_pre_cg_1(Act, StL, outside_seq)} || [C|Act] <- Cs0], {'cond',Cs}; enc_pre_cg_2({error,_}=E, _, _) -> E; enc_pre_cg_2({lc,B0,V,L}, StL, _StB) -> B = enc_pre_cg_1(B0, StL, outside_seq), {lc,B,V,L}; enc_pre_cg_2({put_bits,V,8,[1]}, StL, _StB) -> case StL of in_head -> {integer,V}; in_tail -> {cons,{integer,V},nil}; outside_list -> {cons,{integer,V},nil} end; enc_pre_cg_2({put_bits,V,binary,_}, _StL, _StB) -> V; enc_pre_cg_2({put_bits,_,_,[_]}=PutBits, _StL, _StB) -> {binary,[PutBits]}; enc_pre_cg_2({var,_}=Imm, _, _) -> Imm. enc_make_cons({binary,H}, {binary,T}) -> {binary,H++T}; enc_make_cons({binary,H0}, {cons,{binary,H1},T}) -> enc_make_cons({binary,H0++H1}, T); enc_make_cons({binary,H}, {cons,{integer,Int},T}) -> enc_make_cons({binary,H++[{put_bits,Int,8,[1]}]}, T); enc_make_cons({integer,Int}, {binary,T}) -> {binary,[{put_bits,Int,8,[1]}|T]}; enc_make_cons({integer,Int}, {cons,{binary,H},T}) -> enc_make_cons({binary,[{put_bits,Int,8,[1]}|H]}, T); enc_make_cons(H, T) -> {cons,H,T}. enc_pre_cg_nonbuilding({lc,B0,Var,List,Dst}, StL) -> B = enc_pre_cg_1(B0, StL, outside_seq), {lc,B,Var,List,Dst}; enc_pre_cg_nonbuilding({list,List0,Dst}, _StL) -> List = enc_pre_cg_1(List0, outside_list, outside_seq), {list,List,Dst}; enc_pre_cg_nonbuilding({'try',Try0,{P,Succ0},Else0,Dst}, StL) -> Try = enc_pre_cg_1(Try0, StL, outside_seq), Succ = enc_pre_cg_1(Succ0, StL, outside_seq), Else = enc_pre_cg_1(Else0, StL, outside_seq), {'try',Try,{P,Succ},Else,Dst}; enc_pre_cg_nonbuilding(Imm, _) -> Imm. %%% %%% Optimize calls to complete/1 and surrounding code. There are %%% several opportunities for optimizations. %%% %%% It may be possible to replace the call to complete/1 with %%% something cheaper (most important for the PER back-end which has %%% an expensive complete/1 implementation). If we can be sure that %%% complete/1 will be called with an iolist (no 'align' atoms or %%% bitstrings in the list), we can call iolist_to_binary/1 %%% instead. If the list may include bitstrings, we can can call %%% list_to_bitstring/1 (note that list_to_bitstring/1 does not accept %%% a binary or bitstring, so we MUST be sure that we only pass it a %%% list). If complete/1 is called with a binary, we can omit the %%% call altogether. %%% %%% A call to byte_size/1 that follows complete/1 can be eliminated %%% if the size of the binary produced by complete/1 can be determined %%% and is constant. %%% %%% The code that encodes the length descriptor (a 'cond' instruction) %%% for a binary produced by complete/1 can be simplified if the lower %%% and upper bounds for the size of the binary are known. %%% -record(ost, {sym, t }). enc_opt(Imm0) -> {Imm,_} = enc_opt(Imm0, #ost{sym=gb_trees:empty()}), Imm. enc_opt(align, St) -> {align,St#ost{t=t_align({0,7})}}; enc_opt({apply,What,As}, St) -> {{apply,What,subst_list(As, St)},St#ost{t=t_any()}}; enc_opt({assign,_,_}=Imm, St) -> {Imm,St}; enc_opt({binary,PutBits0}, St) -> PutBits = [{put_bits,subst(V, St),Sz,F} || {put_bits,V,Sz,F} <- PutBits0], NumBits = lists:foldl(fun({put_bits,_,Bits,_}, Sum) -> Sum+Bits end, 0, PutBits), {{binary,PutBits},St#ost{t=t_bitstring(NumBits)}}; enc_opt({block,Bl0}, St0) -> {Bl,St} = enc_opt(Bl0, St0), {{block,Bl},St}; enc_opt({call,binary,encode_unsigned,[Int],Bin}=Imm, St0) -> Type = get_type(Int, St0), St = case t_range(Type) of any -> set_type(Bin, t_binary(), St0); {Lb0,Ub0} -> Lb = bit_size(binary:encode_unsigned(Lb0)), Ub = bit_size(binary:encode_unsigned(Ub0)), set_type(Bin, t_binary({Lb,Ub}), St0) end, {Imm,St}; enc_opt({call,erlang,bit_size,[Bin],Dst}=Imm0, St0) -> Type = get_type(Bin, St0), case t_range(Type) of any -> St1 = set_type(Bin, t_bitstring(), St0), St = propagate(Dst, fun(T, S) -> bit_size_propagate(Bin, T, S) end, St1), {Imm0,St}; {Lb,Ub}=Range -> St = set_type(Dst, t_integer(Range), St0), Imm = case Lb of Ub -> none; _ -> Imm0 end, {Imm,St} end; enc_opt({call,erlang,byte_size,[Bin],Dst}=Imm0, St0) -> Type = get_type(Bin, St0), case t_range(Type) of any -> St1 = set_type(Bin, t_binary(), St0), St = propagate(Dst, fun(T, S) -> byte_size_propagate(Bin, T, S) end, St1), {Imm0,St}; {Lb0,Ub0} -> Lb = (Lb0+7) div 8, Ub = (Ub0+7) div 8, St = set_type(Dst, t_integer({Lb,Ub}), St0), Imm = case Lb of Ub -> none; _ -> Imm0 end, {Imm,St} end; enc_opt({call,erlang,iolist_to_binary,_}=Imm, St) -> {Imm,St#ost{t=t_binary()}}; enc_opt({call,erlang,length,[List],Dst}=Imm0, St0) -> St1 = propagate(Dst, fun(T, S) -> length_propagate(List, T, S) end, St0), {Imm0,St1}; enc_opt({call,per,complete,[Data],Dst}, St0) -> Type = get_type(Data, St0), St = set_type(Dst, t_binary(t_range(Type)), St0), case t_type(Type) of binary -> {{set,Data,Dst},St}; bitlist -> %% We KNOW that list_to_bitstring/1 will construct %% a binary (the number of bits is divisible by 8) %% because per_enc_open_type/2 added an 'align' atom %% at the end. If that 'align' atom had not been %% optimized away, the type would have been 'align' %% instead of 'bitlist'. {{call,erlang,list_to_bitstring,[Data],Dst},St}; iolist -> {{call,erlang,iolist_to_binary,[Data],Dst},St}; nil -> Imm = {list,{binary,[{put_bits,0,8,[1]}]},Dst}, enc_opt(Imm, St0); _ -> {{call,per,complete,[Data],Dst},St} end; enc_opt({call,uper,complete,[Data],Dst}, St0) -> Type = get_type(Data, St0), St = set_type(Dst, t_binary(t_range(Type)), St0), case t_type(Type) of binary -> {{set,Data,Dst},St0}; iolist -> {{call,erlang,iolist_to_binary,[Data],Dst},St}; nil -> Imm = {list,{binary,[{put_bits,0,8,[1]}]},Dst}, enc_opt(Imm, St0); _ -> %% 'bitlist' or 'any'. {{call,uper,complete,[Data],Dst},St} end; enc_opt({call,per_common,encode_chars,[List,NumBits|_],Dst}=Imm, St0) -> %% Note: Never used when NumBits =:= 8 (list_to_binary/1 will %% be used instead). St1 = set_type(Dst, t_bitstring(), St0), St = propagate(List, fun(T, S) -> char_propagate(Dst, T, NumBits, S) end, St1), {Imm,St}; enc_opt({call,per_common,encode_chars_16bit,[List],Dst}=Imm, St0) -> St1 = set_type(Dst, t_binary(), St0), St = propagate(List, fun(T, S) -> char_propagate(Dst, T, 16, S) end, St1), {Imm,St}; enc_opt({call,per_common,encode_big_chars,[List],Dst}=Imm, St0) -> St1 = set_type(Dst, t_binary(), St0), St = propagate(List, fun(T, S) -> char_propagate(Dst, T, 32, S) end, St1), {Imm,St}; enc_opt({call,per_common,encode_fragmented,[_,Unit]}=Imm, St) -> T = case Unit rem 8 of 0 -> t_iolist(); _ -> t_bitlist() end, {Imm,St#ost{t=T}}; enc_opt({call,per_common,encode_unconstrained_number,_}=Imm, St) -> {Imm,St#ost{t=t_iolist()}}; enc_opt({call,per_common,bitstring_from_positions,_}=Imm, St) -> {Imm,St#ost{t=t_bitstring()}}; enc_opt({call,per_common,to_named_bitstring,_}=Imm, St) -> {Imm,St#ost{t=t_bitstring()}}; enc_opt({call,_,_,_}=Imm, St) -> {Imm,St#ost{t=t_any()}}; enc_opt({call,_,_,_,_}=Imm, St) -> {Imm,St#ost{t=undefined}}; enc_opt({call_gen,N,K,F,L,As}, St) -> {{call_gen,N,K,F,L,subst(As, St)},St#ost{t=t_any()}}; enc_opt({'cond',Cs0}, St0) -> case enc_opt_cs(Cs0, St0) of [{'_',Imm,Type}] -> {Imm,St0#ost{t=Type}}; [{Cond,Imm,Type0}|Cs1] -> {Cs,Type} = enc_opt_cond_1(Cs1, Type0, [{Cond,Imm}]), {{'cond',Cs},St0#ost{t=Type}} end; enc_opt({cons,H0,T0}, St0) -> {H,#ost{t=TypeH}=St1} = enc_opt(H0, St0), {T,#ost{t=TypeT}=St} = enc_opt(T0, St1), {{cons,H,T},St#ost{t=t_cons(TypeH, TypeT)}}; enc_opt({error,_}=Imm, St) -> {Imm,St#ost{t=t_any()}}; enc_opt({integer,V}, St) -> {{integer,subst(V, St)},St#ost{t=t_integer()}}; enc_opt({lc,E0,B,C}, St) -> {E,_} = enc_opt(E0, St), {{lc,E,B,C},St#ost{t=t_any()}}; enc_opt({lc,E0,B,C,Dst}, St) -> {E,_} = enc_opt(E0, St), {{lc,E,B,C,Dst},St#ost{t=undefined}}; enc_opt({list,Imm0,Dst}, St0) -> {Imm,#ost{t=Type}=St1} = enc_opt(Imm0, St0), St = set_type(Dst, Type, St1), {{list,Imm,Dst},St#ost{t=undefined}}; enc_opt(nil, St) -> {nil,St#ost{t=t_nil()}}; enc_opt({seq,H0,T0}, St0) -> {H,St1} = enc_opt(H0, St0), {T,St} = enc_opt(T0, St1), case {H,T} of {none,_} -> {T,St}; {{list,Imm,Data}, {seq,{call,per,complete,[Data],_},_}} -> %% Get rid of any explicit 'align' added by per_enc_open_type/2. {{seq,{list,remove_trailing_align(Imm),Data},T},St}; {_,_} -> {{seq,H,T},St} end; enc_opt({set,_,_}=Imm, St) -> {Imm,St#ost{t=undefined}}; enc_opt({sub,Src0,Int,Dst}, St0) -> Src = subst(Src0, St0), Type = get_type(Src, St0), St = case t_range(Type) of any -> propagate(Dst, fun(T, S) -> set_type(Src, t_add(T, Int), S) end, St0); {Lb,Ub} -> set_type(Dst, t_integer({Lb-Int,Ub-Int}), St0) end, {{sub,Src,Int,Dst},St#ost{t=undefined}}; enc_opt({'try',Try0,{P,Succ0},Else0,Dst}, St0) -> {Try,_} = enc_opt(Try0, St0), {Succ,_} = enc_opt(Succ0, St0), {Else,_} = enc_opt(Else0, St0), {{'try',Try,{P,Succ},Else,Dst},St0#ost{t=undefined}}; enc_opt({var,_}=Imm, St) -> Type = get_type(Imm, St), {subst(Imm, St),St#ost{t=Type}}. remove_trailing_align({block,Bl}) -> {block,remove_trailing_align(Bl)}; remove_trailing_align({cons,H,{cons,align,nil}}) -> H; remove_trailing_align({seq,H,T}) -> {seq,H,remove_trailing_align(T)}; remove_trailing_align(Imm) -> Imm. bit_size_propagate(Bin, Type, St) -> case t_range(Type) of any -> St; {Lb,Ub} -> set_type(Bin, t_bitstring({Lb,Ub}), St) end. byte_size_propagate(Bin, Type, St) -> case t_range(Type) of any -> St; {Lb,Ub} -> set_type(Bin, t_binary({Lb*8,Ub*8}), St) end. char_propagate(Dst, T, NumBits, St) -> case t_range(T) of any -> St; {Sz,Sz} when Sz*NumBits rem 8 =:= 0 -> Bits = Sz*NumBits, set_type(Dst, t_binary({Bits,Bits}), St); {Lb,Ub} -> Range = {Lb*NumBits,Ub*NumBits}, case NumBits rem 8 of 0 -> set_type(Dst, t_binary(Range), St); _ -> set_type(Dst, t_bitstring(Range), St) end end. length_propagate(List, Type, St) -> set_type(List, t_list(t_range(Type)), St). enc_opt_cond_1([{Cond,{error,_}=Imm,_}|T], St, Acc) -> enc_opt_cond_1(T, St, [{Cond,Imm}|Acc]); enc_opt_cond_1([{Cond,Imm,Curr0}|T], Curr1, Acc) -> Curr = t_join(Curr0, Curr1), enc_opt_cond_1(T, Curr, [{Cond,Imm}|Acc]); enc_opt_cond_1([], St, Acc) -> {lists:reverse(Acc),St}. enc_opt_cs([{Cond,Imm0}|T], St0) -> case eo_eval_cond(Cond, St0) of false -> enc_opt_cs(T, St0); true -> {Imm,#ost{t=Type}} = enc_opt(Imm0, St0), [{'_',Imm,Type}]; maybe -> St = update_type_info(Cond, St0), {Imm,#ost{t=Type}} = enc_opt(Imm0, St), [{Cond,Imm,Type}|enc_opt_cs(T, St0)] end; enc_opt_cs([], _) -> []. eo_eval_cond('_', _) -> true; eo_eval_cond({Op,{var,_}=Var,Val}, St) -> Type = get_type(Var, St), case t_range(Type) of any -> maybe; {_,_}=Range -> eval_cond_range(Op, Range, Val) end; eo_eval_cond({_Op,{expr,_},_Val}, _St) -> maybe. eval_cond_range(lt, {Lb,Ub}, Val) -> if Ub < Val -> true; Val =< Lb -> false; true -> maybe end; eval_cond_range(_Op, _Range, _Val) -> maybe. update_type_info({ult,{var,_}=Var,Val}, St) -> Int = t_integer({0,Val-1}), Type = t_meet(get_type(Var, St), Int), set_type(Var, Type, St); update_type_info({lt,{var,_}=Var,Val}, St) -> Int = t_integer({0,Val-1}), Type = t_meet(get_type(Var, St), Int), set_type(Var, Type, St); update_type_info({eq,{var,_}=Var,Val}, St) when is_integer(Val) -> Int = t_integer(Val), Type = t_meet(get_type(Var, St), Int), set_type(Var, Type, St); update_type_info({eq,_,_}, St) -> St; update_type_info({ge,_,_}, St) -> St. subst_list(As, St) -> [subst(A, St) || A <- As]. subst({var,_}=Var, St) -> Type = get_type(Var, St), case t_type(Type) of integer -> case t_range(Type) of any -> Var; {Val,Val} -> Val; {_,_} -> Var end; _ -> Var end; subst(V, _St) -> V. set_type({var,Var}, {_,_}=Type, #ost{sym=Sym0}=St0) -> Sym1 = gb_trees:enter(Var, Type, Sym0), case gb_trees:lookup({propagate,Var}, Sym1) of none -> St0#ost{sym=Sym1}; {value,Propagate} -> Sym = gb_trees:delete({propagate,Var}, Sym1), St = St0#ost{sym=Sym}, Propagate(Type, St) end. get_type({var,V}, #ost{sym=Sym}) -> case gb_trees:lookup(V, Sym) of none -> t_any(); {value,T} -> T end. propagate({var,Var}, Propagate, #ost{sym=Sym0}=St) when is_function(Propagate, 2) -> Sym = gb_trees:enter({propagate,Var}, Propagate, Sym0), St#ost{sym=Sym}. %%% %%% A simple type system. %%% %%% Each type descriptions is a tuple {Type,Range}. %%% Type is one of the following atoms: %%% %%% Type name Description %%% --------- ----------- %%% any Anything. %%% %%% align Basically iodata, but the list may contain bitstrings %%% and the the atom 'align'. Can be passed to complete/1 %%% to construct a binary. Only used for aligned PER (per). %%% %%% bitstring An Erlang bitstring. %%% %%% bitlist A list that may be passed to list_to_bitstring/1 to %%% construct a bitstring. %%% NOTE: When analysing aligned PER (per), the number %%% of bits in the bitlist is always divisible by 8 (if %%% not, the type will be 'align' instead). %%% %%% binary An Erlang binary (the number of bits is divisible by 8). %%% %%% iolist An Erlang iolist. %%% %%% nil [] %%% %%% integer An integer. %%% %%% %%% Range is one of: %%% %%% any %%% {LowerBound,UpperBound} %%% %%% t_align(Range) -> {align,t__range(Range)}. t_any() -> {any,any}. t_binary() -> {binary,any}. t_binary(Range) -> {binary,t__range(Range)}. t_bitlist() -> {bitlist,any}. t_bitstring() -> {bitstring,any}. t_bitstring(Range0) -> case t__range(Range0) of {Bits,Bits}=Range when Bits rem 8 =:= 0 -> {binary,Range}; Range -> {bitstring,Range} end. t_add({integer,{Lb,Ub}}, N) -> {integer,{Lb+N,Ub+N}}. t_cons({_,_}=T1, {_,_}=T2) -> T = case {t__cons_type(T1),t__cons_type(T2)} of {_,any} -> any; {any,_} -> any; {align,_} -> align; {_,align} -> align; {binary,binary} -> iolist; {binary,bitstring} -> bitlist; {bitstring,binary} -> bitlist; {bitstring,bitstring} -> bitlist end, {T,t__cons_ranges(t__cons_range(T1), t__cons_range(T2))}. t_integer() -> {integer,any}. t_integer(Range) -> {integer,t__range(Range)}. t_iolist() -> {iolist,any}. t_list(Range) -> {list,t__range(Range)}. t_nil() -> {nil,{0,0}}. t_meet({T1,Range1}, {T2,Range2}) -> {t_meet_types(T1, T2),t_meet_ranges(Range1, Range2)}. t_meet_types(integer, integer) -> integer; t_meet_types(any, integer) -> integer. t_meet_ranges(any, Range) -> Range; t_meet_ranges({Lb1,Ub1}, {Lb2,Ub2}) -> if Lb1 =< Ub2, Lb2 =< Ub1 -> {max(Lb1, Lb2),Ub1}; Lb2 =< Ub1, Lb1 =< Ub2 -> {max(Lb1, Lb2),Ub2} end. t_join({T1,Range1}, {T2,Range2}) -> T = t_join_types(lists:sort([T1,T2])), Range = t_join_ranges(Range1, Range2), {T,Range}. t_join_ranges({Lb1,Ub1}, {Lb2,Ub2}) -> {min(Lb1, Lb2),max(Ub1, Ub2)}; t_join_ranges(any, _) -> any; t_join_ranges(_, any) -> any. t_join_types([T,T]) -> T; t_join_types([align,any]) -> any; t_join_types([align,_]) -> align; t_join_types([any,_]) -> any; t_join_types([bitlist,bitstring]) -> any; t_join_types([bitlist,integer]) -> any; t_join_types([bitlist,iolist]) -> bitlist; t_join_types([bitlist,nil]) -> bitlist; t_join_types([binary,bitlist]) -> bitlist; t_join_types([binary,bitstring]) -> bitstring; t_join_types([binary,integer]) -> binary; t_join_types([binary,iolist]) -> iolist; t_join_types([binary,nil]) -> iolist; t_join_types([bitstring,integer]) -> any; t_join_types([bitstring,iolist]) -> any; t_join_types([bitstring,nil]) -> any; t_join_types([integer,_]) -> any; t_join_types([iolist,nil]) -> iolist. t_type({T,_}) -> T. t_range({_,Range}) -> Range. t__cons_type({align,_}) -> align; t__cons_type({any,_}) -> any; t__cons_type({binary,_}) -> binary; t__cons_type({bitstring,_}) -> bitstring; t__cons_type({bitlist,_}) -> bitstring; t__cons_type({integer,_}) -> binary; t__cons_type({iolist,_}) -> binary; t__cons_type({nil,_}) -> binary. t__cons_range({integer,_}) -> {8,8}; t__cons_range({_,Range}) -> Range. t__cons_ranges({Lb1,Ub1}, {Lb2,Ub2}) -> {Lb1+Lb2,Ub1+Ub2}; t__cons_ranges(any, _) -> any; t__cons_ranges(_, any) -> any. t__range({Lb,Ub}=Range) when is_integer(Lb), is_integer(Ub) -> Range; t__range(any) -> any; t__range(Val) when is_integer(Val) -> {Val,Val}. %%% %%% Code generation for encoding. %%% enc_cg({cons,_,_}=Cons) -> enc_cg_cons(Cons); enc_cg({block,Imm}) -> emit(["begin",nl]), enc_cg(Imm), emit([nl, "end"]); enc_cg({seq,First,Then}) -> enc_cg(First), emit([com,nl]), enc_cg(Then); enc_cg(align) -> emit(align); enc_cg({apply,F0,As0}) -> As = enc_call_args(As0, ""), case F0 of {local,F,_} when is_atom(F) -> emit([{asis,F},"(",As,")"]); {M,F,_} -> emit([{asis,M},":",{asis,F},"(",As,")"]) end; enc_cg({assign,Dst0,Expr}) -> Dst = mk_val(Dst0), emit([Dst," = ",Expr]); enc_cg({binary,PutBits}) -> emit(["<<",enc_cg_put_bits(PutBits, ""),">>"]); enc_cg({call,M,F,As0}) -> As = [mk_val(A) || A <- As0], asn1ct_func:call(M, F, As); enc_cg({call,M,F,As0,Dst}) -> As = [mk_val(A) || A <- As0], emit([mk_val(Dst)," = "]), asn1ct_func:call(M, F, As); enc_cg({call_gen,Prefix,Key,Gen,_,As0}) -> As = [mk_val(A) || A <- As0], asn1ct_func:call_gen(Prefix, Key, Gen, As); enc_cg({'cond',Cs}) -> enc_cg_cond(Cs); enc_cg({error,Error}) when is_function(Error, 0) -> Error(); enc_cg({error,Var0}) -> Var = mk_val(Var0), emit(["exit({error,{asn1,{illegal_value,",Var,"}}})"]); enc_cg({integer,Int}) -> emit(mk_val(Int)); enc_cg({lc,Body,Var,List}) -> emit("["), enc_cg(Body), emit([" || ",mk_val(Var)," <- ",mk_val(List),"]"]); enc_cg({lc,Body,Var,List,Dst}) -> emit([mk_val(Dst)," = ["]), enc_cg(Body), emit([" || ",mk_val(Var)," <- ",mk_val(List),"]"]); enc_cg({list,List,Dst}) -> emit([mk_val(Dst)," = "]), enc_cg(List); enc_cg(nil) -> emit("[]"); enc_cg({sub,Src0,Int,Dst0}) -> Src = mk_val(Src0), Dst = mk_val(Dst0), emit([Dst," = ",Src," - ",Int]); enc_cg({set,{var,Src},{var,Dst}}) -> emit([Dst," = ",Src]); enc_cg({'try',Try,{P,Succ},Else,Dst}) -> emit([mk_val(Dst)," = try "]), enc_cg(Try), emit([" of",nl, mk_val(P)," ->",nl]), enc_cg(Succ), emit([nl, "catch throw:invalid ->",nl]), enc_cg(Else), emit([nl, "end"]); enc_cg({var,V}) -> emit(V). enc_cg_cons(Cons) -> emit("["), enc_cg_cons_1(Cons), emit("]"). enc_cg_cons_1({cons,H,{cons,_,_}=T}) -> enc_cg(H), emit([com,nl]), enc_cg_cons_1(T); enc_cg_cons_1({cons,H,nil}) -> enc_cg(H); enc_cg_cons_1({cons,H,T}) -> enc_cg(H), emit("|"), enc_cg(T). enc_call_args([A|As], Sep) -> [Sep,mk_val(A)|enc_call_args(As, ", ")]; enc_call_args([], _) -> []. enc_cg_cond(Cs) -> emit("if "), enc_cg_cond(Cs, ""), emit([nl, "end"]). enc_cg_cond([C|Cs], Sep) -> emit(Sep), enc_cg_cond_1(C), enc_cg_cond(Cs, [";",nl]); enc_cg_cond([], _) -> ok. enc_cg_cond_1({Cond,Action}) -> enc_cond_term(Cond), emit([" ->",nl]), enc_cg(Action). enc_cond_term('_') -> emit("true"); enc_cond_term({ult,Var0,Int}) -> Var = mk_val(Var0), N = uper_num_bits(Int), case 1 bsl N of Int -> emit([Var," bsr ",N," =:= 0"]); _ -> emit(["0 =< ",Var,", ",Var," < ",Int]) end; enc_cond_term({eq,Var0,Term}) -> Var = mk_val(Var0), emit([Var," =:= ",{asis,Term}]); enc_cond_term({ge,Var0,Int}) -> Var = mk_val(Var0), emit([Var," >= ",Int]); enc_cond_term({lt,Var0,Int}) -> Var = mk_val(Var0), emit([Var," < ",Int]). enc_cg_put_bits([{put_bits,Val0,N,[1]}|T], Sep) -> Val = mk_val(Val0), [[Sep,Val,":",integer_to_list(N)]|enc_cg_put_bits(T, ",")]; enc_cg_put_bits([], _) -> []. mk_val({var,Str}) -> Str; mk_val({expr,Str}) -> Str; mk_val(Int) when is_integer(Int) -> integer_to_list(Int); mk_val(Other) -> {asis,Other}. %%% %%% Generate a function that maps a name of a bit position %%% to the bit position. %%% bit_string_name2pos_fun(NNL, Src) -> {call_gen,"bit_string_name2pos_",NNL, fun(Fd, Name) -> gen_name2pos(Fd, Name, NNL) end,[],[Src]}. gen_name2pos(Fd, Name, Names) -> Cs0 = gen_name2pos_cs(Names, Name), Cs = Cs0 ++ [bit_clause(Name),nil_clause(),invalid_clause()], F = {function,1,Name,1,Cs}, file:write(Fd, [erl_pp:function(F)]). gen_name2pos_cs([{K,V}|T], Name) -> P = [{cons,0,{atom,0,K},{var,0,'T'}}], B = [{cons,0,{integer,0,V},{call,0,{atom,0,Name},[{var,0,'T'}]}}], [{clause,0,P,[],B}|gen_name2pos_cs(T, Name)]; gen_name2pos_cs([], _) -> []. bit_clause(Name) -> VarT = {var,0,'T'}, VarPos = {var,0,'Pos'}, P = [{cons,0,{tuple,0,[{atom,0,bit},VarPos]},VarT}], G = [[{call,0,{atom,0,is_integer},[VarPos]}]], B = [{cons,0,VarPos,{call,0,{atom,0,Name},[VarT]}}], {clause,0,P,G,B}. nil_clause() -> P = B = [{nil,0}], {clause,0,P,[],B}. invalid_clause() -> P = [{var,0,'_'}], B = [{call,0,{atom,0,throw},[{atom,0,invalid}]}], {clause,0,P,[],B}. %%% %%% Hoist alignment to reduce the number of list elements in %%% encode. Fewer lists elements means faster traversal in %%% complete/{2,3}. %%% %%% For example, the following data sequence: %%% %%% [align,<<1:1,0:1>>,[align,<<Len:16>>|Data]] %%% %%% can be rewritten to: %%% %%% [align,<<1:1,0:1,0:6>>,[<<Len:16>>|Data]] %%% %%% The change from the literal <<1:1,0:1>> to <<1:1,0:1,0:6>> %%% comes for free, and we have eliminated one element of the %%% sub list. %%% %%% We must be careful not to rewrite: %%% %%% [<<1:1,0:1>>,[align,<<Len:16>>|Data]] %%% %%% to: %%% %%% [[<<1:1,0:1>>,align],[<<Len:16>>|Data]] %%% %%% because even though [<<1:0,0:1>>,align] is a literal and does %%% not add any additional construction cost, there is one more %%% sub list that needs to be traversed. %%% enc_hoist_align(Imm0) -> Imm = enc_hoist_align_reverse(Imm0, []), enc_hoist_align(Imm, false, []). enc_hoist_align_reverse([H|T], Acc) -> case enc_opt_al_1([H], 0) of {[H],_} -> enc_hoist_align_reverse(T, [H|Acc]); {_,_} -> lists:reverse(T, [H,stop|Acc]) end; enc_hoist_align_reverse([], Acc) -> Acc. enc_hoist_align([stop|T], _Aligned, Acc) -> lists:reverse(T, Acc); enc_hoist_align([{block,Bl0}|T], Aligned, Acc) -> Bl = case Aligned of false -> Bl0; true -> enc_hoist_block(Bl0) end, case is_beginning_aligned(Bl) of false -> enc_hoist_align(T, false, [{block,Bl}|Acc]); true -> enc_hoist_align(T, true, [{put_bits,0,0,[1,align]}, {block,Bl}|Acc]) end; enc_hoist_align([H|T], _, Acc) -> enc_hoist_align(T, false, [H|Acc]); enc_hoist_align([], _, Acc) -> Acc. enc_hoist_block(Bl) -> try enc_hoist_block_1(lists:reverse(Bl)) catch throw:impossible -> Bl end. enc_hoist_block_1([{'cond',Cs0}|T]) -> Cs = [[C|enc_hoist_block_2(Act)] || [C|Act] <- Cs0], H = {'cond',Cs}, lists:reverse(T, [H]); enc_hoist_block_1(_) -> throw(impossible). enc_hoist_block_2([{'cond',_}|_]=L) -> enc_hoist_block(L); enc_hoist_block_2([{error,_}]=L) -> L; enc_hoist_block_2([]) -> [{put_bits,0,0,[1,align]}]; enc_hoist_block_2(L) -> case lists:last(L) of {put_bits,_,_,_} -> L ++ [{put_bits,0,0,[1,align]}]; _ -> throw(impossible) end. %%% %%% Optimize alignment for encoding. %%% enc_opt_al(Imm0) -> {Imm,_} = enc_opt_al_1(Imm0, unknown), Imm. enc_opt_al_1([H0|T0], Al0) -> {H,Al1} = enc_opt_al(H0, Al0), {T,Al} = enc_opt_al_1(T0, Al1), {H++T,Al}; enc_opt_al_1([], Al) -> {[],Al}. enc_opt_al({assign,_,_}=Imm, Al) -> {[Imm],Al}; enc_opt_al({block,Bl0}, Al0) -> {Bl,Al} = enc_opt_al_1(Bl0, Al0), {[{block,Bl}],Al}; enc_opt_al({call,erlang,iolist_to_binary,[_]}=Imm, Al) -> {[Imm],Al}; enc_opt_al({call,per_common,encode_fragmented,[_,U]}=Call, Al) -> case U rem 8 of 0 -> {[Call],Al}; _ -> {[Call],unknown} end; enc_opt_al({call,per_common,encode_unconstrained_number,[_]}=Call, _) -> {[Call],0}; enc_opt_al({call,_,_,_,_}=Call, Al) -> {[Call],Al}; enc_opt_al({'cond',Cs0}, Al0) -> {Cs,Al} = enc_opt_al_cond(Cs0, Al0), {[{'cond',Cs}],Al}; enc_opt_al({error,_}=Imm, Al) -> {[Imm],Al}; enc_opt_al({list,Imm0,Dst}, Al) -> Imm1 = enc_opt_hoist_align(Imm0), {Imm,_} = enc_opt_al_1(Imm1, 0), {[{list,Imm,Dst}],Al}; enc_opt_al({put_bits,V,N,[U,align]}, Al0) when Al0 rem 8 =:= 0 -> Al = if is_integer(N) -> N*U; N =:= binary, U rem 8 =:= 0 -> 0; true -> unknown end, {[{put_bits,V,N,[U]}],Al}; enc_opt_al({put_bits,V,binary,[U,align]}, Al0) when is_integer(Al0) -> N = 8 - (Al0 rem 8), Al = case U rem 8 of 0 -> 0; _ -> unknown end, {[{put_bits,0,N,[1]},{put_bits,V,binary,[U]}],Al}; enc_opt_al({put_bits,V,N0,[U,align]}, Al0) when is_integer(N0), is_integer(Al0) -> N = N0 + (8 - Al0 rem 8), Al = N0*U, {[{put_bits,V,N,[1]}],Al}; enc_opt_al({put_bits,_,N,[U,align]}=PutBits, _) when is_integer(N) -> {[PutBits],N*U}; enc_opt_al({put_bits,_,binary,[U,align]}=PutBits, _) when U rem 8 =:= 0 -> {[PutBits],0}; enc_opt_al({put_bits,_,N,[U]}=PutBits, Al) when is_integer(N), is_integer(Al) -> {[PutBits],Al+N*U}; enc_opt_al({put_bits,_,binary,[U]}=PutBits, Al) when U rem 8 =:= 0 -> {[PutBits],Al}; enc_opt_al({set,_,_}=Imm, Al) -> {[Imm],Al}; enc_opt_al({sub,_,_,_}=Imm, Al) -> {[Imm],Al}; enc_opt_al({'try',_,_,_,_}=Imm, Al) -> {[Imm],Al}; enc_opt_al(Imm, _) -> {[Imm],unknown}. enc_opt_al_cond(Cs0, Al0) -> enc_opt_al_cond_1(Cs0, Al0, [], []). enc_opt_al_cond_1([['_',{error,_}]=C|Cs], Al, CAcc, AAcc) -> enc_opt_al_cond_1(Cs, Al, [C|CAcc], AAcc); enc_opt_al_cond_1([[C|Act0]|Cs0], Al0, CAcc, AAcc) -> {Act,Al1} = enc_opt_al_1(Act0, Al0), Al = if Al1 =:= unknown -> Al1; true -> Al1 rem 8 end, enc_opt_al_cond_1(Cs0, Al0, [[C|Act]|CAcc], [Al|AAcc]); enc_opt_al_cond_1([], _, CAcc, AAcc) -> Al = case lists:usort(AAcc) of [] -> unknown; [Al0] -> Al0; [_|_] -> unknown end, {lists:reverse(CAcc),Al}. enc_opt_hoist_align([{'cond',Cs0},{put_bits,0,0,[1,align]}]=Imm) -> try Cs = [insert_align_last(C) || C <- Cs0], [{'cond',Cs}] catch throw:impossible -> Imm end; enc_opt_hoist_align(Imm) -> Imm. insert_align_last([_,{error,_}]=C) -> C; insert_align_last([H|T]) -> case lists:last(T) of {put_bits,_,_,_} -> [H|T ++ [{put_bits,0,0,[1,align]}]]; _ -> throw(impossible) end. %%% %%% For the aligned PER format, fix up the intermediate format %%% before code generation. Code generation will be somewhat %%% easier if 'align' appear as a separate instruction. %%% per_fixup([{apply,_,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([{block,Block}|T]) -> [{block,per_fixup(Block)}|per_fixup(T)]; per_fixup([{'assign',_,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([{'cond',Cs0}|T]) -> Cs = [[C|per_fixup(Act)] || [C|Act] <- Cs0], [{'cond',Cs}|per_fixup(T)]; per_fixup([{call,_,_,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([{call,_,_,_,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([{call_gen,_,_,_,_,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([{error,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([{lc,B,V,L}|T]) -> [{lc,per_fixup(B),V,L}|per_fixup(T)]; per_fixup([{lc,B,V,L,Dst}|T]) -> [{lc,per_fixup(B),V,L,Dst}|per_fixup(T)]; per_fixup([{list,Imm,Dst}|T]) -> [{list,per_fixup(Imm),Dst}|per_fixup(T)]; per_fixup([{set,_,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([{sub,_,_,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([{'try',Try0,{P,Succ0},Else0,Dst}|T]) -> Try = per_fixup(Try0), Succ = per_fixup(Succ0), Else = per_fixup(Else0), [{'try',Try,{P,Succ},Else,Dst}|per_fixup(T)]; per_fixup([{put_bits,_,_,_}|_]=L) -> fixup_put_bits(L); per_fixup([{var,_}=H|T]) -> [H|per_fixup(T)]; per_fixup([]) -> []. fixup_put_bits([{put_bits,0,0,[_,align]}|T]) -> [align|fixup_put_bits(T)]; fixup_put_bits([{put_bits,0,0,_}|T]) -> fixup_put_bits(T); fixup_put_bits([{put_bits,V,N,[U,align]}|T]) -> [align,{put_bits,V,N,[U]}|fixup_put_bits(T)]; fixup_put_bits([{put_bits,_,_,_}=H|T]) -> [H|fixup_put_bits(T)]; fixup_put_bits(Other) -> per_fixup(Other). %% effective_constraint(Type,C) %% Type = atom() %% C = [C1,...] %% C1 = {'SingleValue',SV} | {'ValueRange',VR} | {atom(),term()} %% SV = integer() | [integer(),...] %% VR = {Lb,Ub} %% Lb = 'MIN' | integer() %% Ub = 'MAX' | integer() %% Returns a single value if C only has a single value constraint, and no %% value range constraints, that constrains to a single value, otherwise %% returns a value range that has the lower bound set to the lowest value %% of all single values and lower bound values in C and the upper bound to %% the greatest value. effective_constraint(integer, [{{_,_}=Root,_}|_Rest]) -> %% Normalize extension. Note that any range given for the %% extension should be ignored anyway. [{Root,[]}]; effective_constraint(integer, C) -> SVs = get_constraints(C, 'SingleValue'), SV = effective_constr('SingleValue', SVs), VRs = get_constraints(C, 'ValueRange'), VR = effective_constr('ValueRange', VRs), greatest_common_range(SV, VR); effective_constraint(bitstring, C) -> 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) -> SVList = lists:flatten(lists:map(fun(X) -> element(2, X) end, List)), %% Sort and remove duplicates before generating SingleValue or ValueRange %% In case of ValueRange, also check for 'MIN and 'MAX' case lists:usort(SVList) of [N] -> [{'SingleValue',N}]; [_|_]=L -> [{'ValueRange',{least_Lb(L),greatest_Ub(L)}}] end; effective_constr('ValueRange', List) -> LBs = lists:map(fun({_,{Lb,_}}) -> Lb end, List), UBs = lists:map(fun({_,{_,Ub}}) -> Ub end, List), Lb = least_Lb(LBs), [{'ValueRange',{Lb,lists:max(UBs)}}]. greatest_common_range([], VR) -> VR; greatest_common_range(SV, []) -> SV; greatest_common_range([{_,Int}], [{_,{'MIN',Ub}}]) when is_integer(Int), Int > Ub -> [{'ValueRange',{'MIN',Int}}]; greatest_common_range([{_,Int}],[{_,{Lb,Ub}}]) when is_integer(Int), Int < Lb -> [{'ValueRange',{Int,Ub}}]; greatest_common_range([{_,Int}],VR=[{_,{_Lb,_Ub}}]) when is_integer(Int) -> VR; greatest_common_range([{_,L}],[{_,{Lb,Ub}}]) when is_list(L) -> Min = least_Lb([Lb|L]), Max = greatest_Ub([Ub|L]), [{'ValueRange',{Min,Max}}]; greatest_common_range([{_,{Lb1,Ub1}}], [{_,{Lb2,Ub2}}]) -> Min = least_Lb([Lb1,Lb2]), Max = greatest_Ub([Ub1,Ub2]), [{'ValueRange',{Min,Max}}]. least_Lb(L) -> case lists:member('MIN', L) of true -> 'MIN'; false -> lists:min(L) end. greatest_Ub(L) -> case lists:member('MAX', L) of true -> 'MAX'; false -> lists:max(L) end. get_constraint(C, Key) -> case lists:keyfind(Key, 1, C) of false -> no; {_,V} -> V end. get_constraints([{Key,_}=Pair|T], Key) -> [Pair|get_constraints(T, Key)]; get_constraints([_|T], Key) -> get_constraints(T, Key); get_constraints([], _) -> [].