aboutsummaryrefslogtreecommitdiffstats
path: root/lib/asn1/src/asn1ct_imm.erl
AgeCommit message (Collapse)Author
2016-03-15update copyright-yearHenrik Nord
2016-01-21PER: Correct compilation of named INTEGERsBjörn Gustavsson
When a constrained INTEGER has more than 16536 values and named values, the compiler would crash when compiling to the PER format. Example: Longitude ::= INTEGER { oneMicrodegreeEast(10), oneMicrodegreeWest(-10), unavailable(1800000001) } (-1799999999..1800000001) Reported-by: Ingars
2015-06-18Change license text to APLv2Bruce Yinhe
2015-04-30asn1: Use module erl_annoHans Bolinder
2015-03-17PER, UPER: Eliminate compiler warning for SeqPrim.asn1Björn Gustavsson
The BEAM compiler now warns more aggressively for expressions whose values are not used. For example, the generated Erlang code for the following ASN.1 code will now cause a warning: Seq ::= SEQUENCE { ..., os OCTET STRING (SIZE (17000..30000)) } The generated Erlang code looks similar to the following: Enc9@bin = iolist_to_binary(Enc9@output), Enc9@len = byte_size(Enc9@bin), [align|encode_fragmented(Enc9@bin, 8)] The variable Enc9@len is not used and the BEAM compiler will complain that the value returned from the byte_size/1 call is not used. Improve the optimization of the intermediate code to eliminate the assignment to the unused variable.
2015-01-16Merge branch 'oliv3/math_log2/OTP-12411'Marcus Arendt
* oliv3/math_log2/OTP-12411: Add math:log2/1
2015-01-14Add math:log2/1Olivier Girondel
2015-01-12Rewrite constraint handlingBjörn Gustavsson
The internal representation for constraints (and object sets) as produced by the parser was awkward, making further processing convoluted. Here follows some examples of the old representation for INTEGER constraints. The constraint 1..2 is represented as: {'ValueRange',{1,2}} If we extend the constraint like this: 1..2, ..., or like this: 1..2, ..., 3 the representation would be: {{'ValueRange',{1,2}},[]} and {{'ValueRange',{1,2}},{'SingleValue',3}} respectively. Note that the pattern {A,B} will match all these constraints. When combining constraints using set operators: 1..2 | 3..4 ^ 5..6 the representation will no longer be a tuple but a list: [{'ValueRange',{1..2}} union {'ValueRange',{3..4}} intersection {'ValueRange',{5..6}}] The parse has full knowledge of the operator precedence; unfortunately, the following pass (asn1ct_check) must also have the same knowledge in order to correctly evaluate the constraints. If we would change the order of the evaulation with round brackets: (1..2 | 3..4) ^ 5..6 there would be a nested listed in the representation: [[{'ValueRange',{1..2}} union {'ValueRange',{3..4}}] intersection {'ValueRange',{5..6}}] We will change the representation to make it more explicit. At the outer level, a constraint is always represented as {element_set,Root,Extension} Extension will be 'none' if there is no extension, and 'empty' if there is an empty extension. Root may also be 'empty' in an object set if there are no objects in the root. Thus the constraints: 1..2 1..2, ... 1..2, ..., 3 will be represented as: {element_set,{'ValueRange',{1,2}},none} {element_set,{'ValueRange',{1,2}},empty} {element_set,{'ValueRange',{1,2}},{'SingleValue',3}} We will change the set operators too. This constraint: 1..2 | 3..4 ^ 5..6 will be represented as: {element_set, {union, {'ValueRange',{1,2}}, {intersection, {'ValueRange',{3,4}}, {'ValueRange',{5,6}}}, none}} which is trivial to understand and evaluate. Similarly: (1..2 | 3..4) ^ 5..6 will be represented as: {element_set, {intersection, {union,{'ValueRange',{1,2}},{'ValueRange',{3,4}}}, {'ValueRange',{5,6}}}, none}
2014-06-05(U)PER: Fix decoding of named INTEGERBjörn Gustavsson
2014-06-05(U)PER: Fix encoding of a semi-constrained, named INTEGERBjörn Gustavsson
The code generator would crash.
2014-06-05(U)PER: Optimize handling of named BIT STRING with a lower zero boundBjörn Gustavsson
If a named BIT STRING has a lower size bound of 0, treat it the same way as if there was no constraint for the purposes of trailing zero bits. That change will eliminate a dialyzer warning.
2014-06-05PER: Optimize encoding of character strings with simple rangesBjörn Gustavsson
The encoder for the following type would generate a dialyzer warning: Ns ::= NumericString (FROM ("0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9")) Optimize this case to make it slightly faster as well as eliminate the dialyzer warning.
2014-01-24Fix OCTET STRINGBjörn Gustavsson
2014-01-24Fix BIT STRINGBjörn Gustavsson
2014-01-20Optimize code surrounding calls to complete/1Björn Gustavsson
complete/1 is used when encoding open types (as well as in the encode/2 function in a generated module). The use of complete/1 for encoding open types used to be optimized in two different places. One place was in the alignment optimization pass, where we attempted to replace the call to complete/1 with a call to iolist_to_binary/1. That optimization was taken out in a previous commit that introduced the {list,_,_} intermediate instruction. The other place was when creating the intermediate representation for the encoding of the open type. When attempting to wrap primitive types in an open type, we would attempt to optimize the encoding of the length decscriptor. We will remove that optimization in this commit. Since the previous two optimizations did not optimize encoding of open types as much as we would want, we will introduce a new optimization in a separate pass that will go further than the previous optimizations.
2014-01-20asn1ct_imm: Add the intermediate instruction {list,List,Dst}Björn Gustavsson
The {list,List,Dst} instruction gives us as general way to capture the building of something into a variable. That will make inlining of intermediate code much easier. It also allows us to eliminate the versions of the apply, call_gen, and cond instructions that takes a target variable. Also remove the optimization in the alignment optimization pass that attempts to replace calls to complete/1 with calls to iolist_to_binary/1. That optimization will not work anymore without rewriting, so we will remove it in this commit and introcude a more powerful optimization in a future commit.
2014-01-20Generate intermediate code that is easier to optimizeBjörn Gustavsson
Instead of generating: {assign,Dst,"element(2, Val)"} generate: {call,erlang,element,[2,{var,"Val"}],Dst} The latter expression is easier to understand since there is no need to parse a string which may contain an arbitrary expression. While at it, also discontinue the practice to treat "naked" atoms as variables. A variable must always be given as {var,String}.
2014-01-20asn1ct_imm: Add the {set,{var,Src},{var,Dst}} instructionBjörn Gustavsson
The {assign,Dst,Src} instruction is difficult to cope with when doing advanced optimizations, since its source argument is a string which may contain any expression. Instead of changing how {assign,_,_} works, we will introduce new instructions that can be used instead of {assign,_}, and remove {assign,_,_} in a later commit when it is no longer used. The first new instruction we will introduce is: {set,{var,Src},{var,Dst}} It is useful for common sub-expression elemination among other things. For the moment, we will only allow a variable as a source argument, but we could extend it in the future to allow constants as well.
2014-01-20Keep type information in the apply intermediate instructionBjörn Gustavsson
To facilitate inlining of apply calls in the intermediate format.
2014-01-20asn1ct_imm: Add a field for intermediate code for call_genBjörn Gustavsson
It will greatly facilitate further optimizations if we include the intermediate code (if available) in the call_gen tuple.
2014-01-20Improve optimization of alignment for encodingBjörn Gustavsson
2014-01-20Improve construction of {cons,H,T} instructionsBjörn Gustavsson
Make sure that we don't construct: {cons,{integer,I},{cons,{binary,B},T}} - OR - {cons,{binary,B},{cons,{integer,I},T}} but: {cons,{binary,[{put_bits,I,8,[1]}|B]},T} - OR - {cons,{binary,B++[{put_bits,I,8,[1]}]},T}
2013-12-02Merge branch 'bjorn/asn1/fix-integer-constraint/OTP-11504' into maintBjörn Gustavsson
* bjorn/asn1/fix-integer-constraint/OTP-11504: PER/UPER: Handle a range in the extension part of the constraint
2013-11-29PER/UPER: Handle a range in the extension part of the constraintBjörn Gustavsson
Constraints such as: INTEGER (1..10, ..., 11..20) would fail to compile. Make sure it is properly ignored.
2013-10-21Merge branch 'bjorn/asn1/fix-extensible-single-values/OTP-11415' into maintBjörn Gustavsson
* bjorn/asn1/fix-extensible-single-values/OTP-11415: PER/UPER: Correct encoding for single-value extensible constraints asn1ct_value: Handle named INTEGERs with constraints
2013-10-01Fix broken handling of default values for BIT STRINGsBjörn Gustavsson
For DER/PER/UPER, a value equal to the DEFAULT is not supposed to be encoded. BIT STRINGs values can be represented as Erlang terms in four different ways: as an integer, as a list of zeroes and ones, as a {Unused,Binary} tuple, or as an Erlang bitstring. When encoding a BIT STRING, only certain representations of BIT STRINGs values were recognized. All representations must be recognized. When decoding a DEFAULT value for a BIT STRING, the actual value given in the decoding would be either an integer or a list of zeroes and one (depending on how the literal was written in the specification). We expect that the default value should be in the same representation as any other BIT STRING value (i.e. by default an Erlang bitstring, or a list if the 'legacy_bitstring' option has been given, or as compact bitstring if 'compact_bitstring' has been given).
2013-09-30PER/UPER: Correct encoding for single-value extensible constraintsBjörn Gustavsson
An extensible constraint which is a union of single values, such as: INTEGER (1|17, ...) would be incorrectly encoded.
2013-09-03PER, UPER: Fix encoding/decoding of open types greater than 16KBjörn Gustavsson
2013-09-03PER, UPER: Optimize table constraintsBjörn Gustavsson
The generated code for table constraints has several problems: * For each object set, a function for getting an encoding or decoding fun is generated, regardless of whether it is actually used. In many specifications, the object set actually used is the union of several other object sets. That means that the code can become a lot bulkier than it would need to be. * The funs are not necessary. The funs just add to the code bloat and generate more unnecessary garbage at run-time. Also, one of the arguments of the fun is the name of the field in the class which is known at compile-time, and the fun for decoding has unused arguments. How to fix the problems: At each call site where an open type should be encoded/decoded, call a specific generated function specialized for the actual object set and the name of the field in the class. When generating the specialized functions, make sure that we re-use a previously generated function if possible.
2013-08-30PER, UPER: Optimize encoding using an intermediate formatBjörn Gustavsson
There are some minor incompatibilities for BIT STRING: {bit,Position} is now only only supported for a named BIT STRING type. Values longer than the maximum size for the BIT STRING type would be truncated silently - they now cause an exception.
2013-08-26asn1ct_imm: Break out the rule for string alignmentBjörn Gustavsson
Break out the the rules for determining whether a string should be in aligned so that it can be reused for encoding.
2013-06-08PER/UPER: Correct decoding of SEQUENCEs with more than 64 extensionsBjörn Gustavsson
2013-05-31PER/UPER: Fix decoding of semi-constrained INTEGERsBjörn Gustavsson
A semi-constrained INTEGER with a non-zero lower bound would be incorrectly decoded. This bug was introduced in R16.
2013-05-31Normalize SIZE constraints to simplify backendsBjörn Gustavsson
2013-05-31PER: Fix aligments bugs for short stringsBjörn Gustavsson
The encoder wrongly assumed that a known multiplier string (such as IA5String) encoded as exactly 16 bits did not need to be aligned to an octet boundary. X.691 (07/2002) 27.5.7 says that it does. Since an OCTET STRING encoded to 16 bits (two octets) should not be aligned to an octet boundary, that means that asnct_imm:dec_string() needs an additional parameter to determine whether a string of a given length needs to be aligned. Furthermore, there is another subtle rule difference: An OCTET STRING which does not have fixed length is always aligned (in PER), but a known multiplier string is aligned if its upper bound is greater than or equal to 16. In encoding, make sure that short known multiplier strings and OCTET STRINGs with extensible sizes are not aligned when they are below the appropriate limit.
2013-05-31asn1_constructed_per: Optimize decoding of CHOICEBjörn Gustavsson
Optimize the decoding of CHOICE. Most important is to inline decoding of the extension bit (if present) and decoding of the choice index to give the BEAM compiler more opportunities for optimization. We will also change the structure of the generated code. The current code uses a flattened case for both the root and extension alternatives: case Choice + NumRootChoices * Ext of %% Root alternatives. 0 - ...; : LastRootAlternative -> ...; %% Extension alternatives. LastRootAlternative+1 -> ...; : %% Unknown extension. _ -> ...; end We will instead generate nested cases: case Ext of 0 -> case Choice of %% Root alternatives. 0 - ...; : LastRootAlternative -> ... end; 1 -> %% Extension alternatives. <Decode the open type here> case Choice of 0 -> ...; : LastExtensionAlternative -> ...; %% Unknown extension. _ -> ...; end end Nested cases should be slightly faster. For decoding of the extensions, it also makes it possible to hoist the decoding of the open type up from each case to before the case switching on the extension index, thus reducing the size of the generated code. We will also do another change to the structure. Currently, the big flat clase is wrapped in code that repackages the return values: {Alt,{Value,RemainingEncodedData}} = case Choice + NumRootChoices * Ext of : end, {{Value,Alt},RemainingEncodedData}. We still need to do the repackaging, but we can push it down to the case arm for decoding each alternative. In many cases, that will give the BEAM compiler the opportunity to avoid building the temporary tuples.
2013-03-08PER/UPER: Correct decoding of ENUMERATEDs with a single valueBjörn Gustavsson
An ENUMERATED with as single value is not encoded. The decoder incorrectly assumed that it was encoded in one bit.
2013-01-25Update copyright yearsBjörn-Egil Dahlberg
2013-01-23per,uper: Optimize decoding of the remaining data typesBjörn Gustavsson
2013-01-23per,uper: Optimize decoding of the remaining string typesBjörn Gustavsson
2013-01-23per,uper: Optimize decoding of the string data typesBjörn Gustavsson
2013-01-22Enumeration decoding: Don't emit a default clause if it cannot matchBjörn Gustavsson
Dialyzer will warn for default clauses that cannot possible match.
2013-01-22Refactor decoding of BIT STRINGsBjörn Gustavsson
Refactor decoding of BIT STRINGs so that the run-time code does not spend testing conditions that are known already at compile-time (which wastes time and produces unnecessary Dialyzer warnings). There are three ways to decode BIT STRINGs: 1) To a list of bit names (and {bit,Position} for unnamed positions) if the BIT STRING type has any bit names. 2a) To a list of ones and zeros if there are no named bits, and the compact_bit_string option was NOT given. 2b) To a {Unused,Bin} tuple if there are no named bits compact_bit_string option WAS given. Structure the decoding functions in the same way.
2013-01-22Add run-time library templates and use themBjörn Gustavsson
The template modules (asn1rtt_*.erl) are based on the existing run-time modules, but with some simplifications and improvements, for example: The run-time functions for BER encoding took a Constraint argument which was not used. It has been eliminated, along with the unused StringType argument for the encode_restricted_string function. The Range argument for decode_enumerated() has been dropped since it was not used.
2013-01-22Add a mechanism for embedding run-time functions into the generated codeBjörn Gustavsson
2012-12-06Optimize decoding of extensionsBjörn Gustavsson
2012-12-06Do alignment optimization of SEQUENCEs and SETsBjörn Gustavsson
2012-12-06Teach asn1ct_imm to optimize alignmentBjörn Gustavsson
2012-12-06Optimize decoding of OCTET STRINGsBjörn Gustavsson
Decoding of fragmented OCTET STRINGs was only implemented when the size was constrained to a single value. While at it, support decoding fragmented OCTET STRINGS in all circumstances.
2012-12-06Add the asn1ct_imm moduleBjörn Gustavsson