{
    "mode": "perldoc",
    "parameter": "Convert::BER",
    "section": "",
    "url": "https://www.chedong.com/phpMan.php/perldoc/Convert%3A%3ABER/json",
    "generated": "2026-06-09T13:11:38Z",
    "synopsis": "use Convert::BER;\n$ber = new Convert::BER;\n$ber->encode(\nINTEGER => 1,\nSEQUENCE => [\nBOOLEAN => 0,\nSTRING => \"Hello\",\n],\nREAL => 3.7,\n);\n$ber->decode(\nINTEGER => \\$i,\nSEQUENCE => [\nBOOLEAN => \\$b,\nSTRING => \\$s,\n],\nREAL => \\$r,\n);",
    "sections": {
        "NAME": {
            "content": "Convert::BER - ASN.1 Basic Encoding Rules\n",
            "subsections": []
        },
        "SYNOPSIS": {
            "content": "use Convert::BER;\n\n$ber = new Convert::BER;\n\n$ber->encode(\nINTEGER => 1,\nSEQUENCE => [\nBOOLEAN => 0,\nSTRING => \"Hello\",\n],\nREAL => 3.7,\n);\n\n$ber->decode(\nINTEGER => \\$i,\nSEQUENCE => [\nBOOLEAN => \\$b,\nSTRING => \\$s,\n],\nREAL => \\$r,\n);\n",
            "subsections": []
        },
        "DESCRIPTION": {
            "content": "WARNING this module is no longer supported, See Convert::ASN1\n\n\"Convert::BER\" provides an OO interface to encoding and decoding data using the ASN.1 Basic\nEncoding Rules (BER), a platform independent way of encoding structured binary data together\nwith the structure.\n",
            "subsections": []
        },
        "METHODS": {
            "content": "new\nnew ( BUFFER )\nnew ( opList )\n\"new\" creates a new \"Convert::BER\" object.\n\nencode ( opList )\nEncode data in *opList* appending to the data in the buffer.\n\ndecode ( opList )\nDecode the data in the buffer as described by *opList*, starting where the last decode\nfinished or position set by \"pos\".\n\nbuffer ( [ BUFFER ] )\nReturn the buffer contents. If *BUFFER* is specified set the buffer contents and reset pos\nto zero.\n\npos ( [ POS ] )\nWithout any arguments \"pos\" returns the offset where the last decode finished, or the last\noffset set by \"pos\". If *POS* is specified then *POS* will be where the next decode starts.\n\ntag ( )\nReturns the tag at the current position in the buffer.\n\nlength ( )\nReturns the length of the buffer.\n\nerror ( )\nReturns the error message associated with the last method, if any. This value is not\nautomatically reset. If \"encode\" or \"decode\" returns undef, check this.\n\ndump ( [ FH ] )\nDump the buffer to the filehandle \"FH\", or STDERR if not specified. The output contains the\nhex dump of each element, and an ASN.1-like text representation of that element.\n\nhexdump ( [ FH ] )\nDump the buffer to the filehandle \"FH\", or STDERR if not specified. The output is hex with\nthe possibly-printable text alongside.\n",
            "subsections": []
        },
        "IO METHODS": {
            "content": "read ( IO )\nwrite ( IO )\nrecv ( SOCK )\nsend ( SOCK [, ADDR ] )\n",
            "subsections": []
        },
        "OPLIST": {
            "content": "An *opList* is a list of *operator*-*value* pairs. An operator can be any of those defined\nbelow, or any defined by sub-classing \"Convert::BER\", which will probably be derived from the\nprimitives given here.\n\nThe *value*s depend on whether BER is being encoded or decoded:\n\nEncoding\nIf the *value* is a scalar, just encode it. If the *value* is a reference to a list, then\nencode each item in the list in turn. If the *value* is a code reference, then execute the\ncode. If the returned value is a scalar, encode that value. If the returned value is a\nreference to a list, encode each item in the list in turn.\n\nDecoding\nIf the *value* is a reference to a scalar, decode the value into the scalar. If the *value*\nis a reference to a list, then decode all the items of this type into the list. Note that\nthere must be at least one item to decode, otherwise the decode will fail. If the *value* is\na code reference, then execute the code and decode the value into the reference returned\nfrom the evaluated code.\n",
            "subsections": []
        },
        "PRIMITIVE OPERATORS": {
            "content": "These operators encode and decode the basic primitive types defined by BER.\n\nBOOLEAN\nA BOOLEAN value is either true or false.\n\nEncoding\nThe *value* is tested for boolean truth, and encoded appropriately.\n\n# Encode a TRUE value\n$ber->encode(\nBOOLEAN => 1,\n) or die;\n\nDecoding\nThe decoded *value*s will be either 1 or 0.\n\n# Decode a boolean value into $bval\n$ber->decode(\nBOOLEAN => \\$bval,\n) or die;\n\nINTEGER\nAn INTEGER value is either a positive whole number, or a negative whole number, or zero. Numbers\ncan either be native perl integers, or values of the \"Math::BigInt\" class.\n\nEncoding\nThe *value* is the integer value to be encoded.\n\n$ber->encode(\nINTEGER => -123456,\n) or die;\n\nDecoding\nThe *value* will be the decoded integer value.\n\n$ber->decode(\nINTEGER => \\$ival,\n) or die;\n\nSTRING\nThis is an OCTET STRING, which is an arbitrarily long binary value.\n\nEncoding\nThe *value* contains the binary value to be encoded.\n\n$ber->encode(\nSTRING => \"\\xC0First character is hex C0\",\n) or die;\n\nDecoding\nThe *value* will be the binary bytes.\n\n$ber->decode(\nSTRING => \\$sval,\n) or die;\n\nNULL\nThere is no value for NULL. You often use NULL in ASN.1 when you want to denote that something\nelse is absent rather than just not encoding the 'something else'.\n\nEncoding\nThe *value*s are ignored, but must be present.\n\n$ber->encode(\nNULL => undef,\n) or die;\n\nDecoding\nDummy values are stored in the returned *value*s, as though they were present in the\nencoding.\n\n$ber->decode(\nNULL => \\$nval,\n) or die;\n\nOBJECTID\nAn OBJECTID value is an OBJECT IDENTIFIER (also called an OID). This is a hierarchically\nstructured value that is used in protocols to uniquely identify something. For example, SNMP\n(the Simple Network Management Protocol) uses OIDs to denote the information being requested,\nand LDAP (the Lightweight Directory Access Protocol, RFC 2251) uses OIDs to denote each\nattribute in a directory entry.\n\nEach level of the OID hierarchy is either zero or a positive integer.\n\nEncoding\nThe *value* should be a dotted-decimal representation of the OID.\n\n$ber->encode(\nOBJECTID => '2.5.4.0', # LDAP objectClass\n) or die;\n\nDecoding\nThe *value* will be the dotted-decimal representation of the OID.\n\n$ber->decode(\nOBJECTID => \\$oval,\n) or die;\n\nENUM\nThe ENUMERATED type is effectively the same as the INTEGER type. It exists so that friendly\nnames can be assigned to certain integer values. To be useful, you should sub-class this\noperator.\n\nBITSTRING\nThe BIT STRING type is an arbitrarily long string of bits - 0's and 1's.\n\nEncoding\nThe *value* is a string of arbitrary 0 and 1 characters. As these are packed into 8-bit\noctets when encoding and there may not be a multiple of 8 bits to be encoded, trailing\npadding bits are added in the encoding.\n\n$ber->encode(\nBITSTRING => '0011',\n) or die;\n\nDecoding\nThe *value* will be a string of 0 and 1 characters. The string will have the same number of\nbits as were encoded (the padding bits are ignored.)\n\n$ber->decode(\nBITSTRING => \\$bval,\n) or die;\n\nBITSTRING8\nThis is a variation of the BITSTRING operator, which is optimized for writing bit strings which\nare multiples of 8-bits in length. You can use the BITSTRING operator to decode BER encoded\nwith the BITSTRING8 operator (and vice-versa.)\n\nEncoding\nThe *value* should be the packed bits to encode, not a string of 0 and 1 characters.\n\n$ber->encode(\nBITSTRING8 => pack('B8', '10110101'),\n) or die;\n\nDecoding\nThe *value* will be the decoded packed bits.\n\n$ber->decode(\nBITSTRING8 => \\$bval,\n) or die;\n\nREAL\nThe REAL type encodes an floating-point number. It requires the POSIX module.\n\nEncoding\nThe *value* should be the number to encode.\n\n$ber->encode(\nREAL => 3.14159265358979,\n) or die;\n\nDecoding\nThe *value* will be the decoded floating-point value.\n\n$ber->decode(\nREAL => \\$rval,\n);\n",
            "subsections": [
                {
                    "name": "ObjectDescriptor",
                    "content": "The ObjectDescriptor type encodes an ObjectDescriptor string. It is a sub-class of \"STRING\".\n\nUTF8String\nThe UTF8String type encodes a string encoded in UTF-8. It is a sub-class of \"STRING\".\n"
                },
                {
                    "name": "NumericString",
                    "content": "The NumericString type encodes a NumericString, which is defined to only contain the characters\n0-9 and space. It is a sub-class of \"STRING\".\n"
                },
                {
                    "name": "PrintableString",
                    "content": "The PrintableString type encodes a PrintableString, which is defined to only contain the\ncharacters A-Z, a-z, 0-9, space, and the punctuation characters ()-+=:',./?. It is a sub-class\nof \"STRING\".\n\nTeletexString/T61String\nThe TeletexString type encodes a TeletexString, which is a string containing characters\naccording to the T.61 character set. Each T.61 character may be one or more bytes wide. It is a\nsub-class of \"STRING\".\n\nT61String is an alternative name for TeletexString.\n"
                },
                {
                    "name": "VideotexString",
                    "content": "The VideotexString type encodes a VideotexString, which is a string. It is a sub-class of\n\"STRING\".\n\nIA5String\nThe IA5String type encodes an IA5String. IA5 (International Alphabet 5) is equivalent to\nUS-ASCII. It is a sub-class of \"STRING\".\n\nUTCTime\nThe UTCTime type encodes a UTCTime value. Note this value only represents years using two\ndigits, so it is not recommended in Y2K-compliant applications. It is a sub-class of \"STRING\".\n\nUTCTime values must be strings like:\n\nyymmddHHMM[SS]Z\nor:\nyymmddHHMM[SS]sHHMM\n\nWhere yy is the year, mm is the month (01-12), dd is the day (01-31), HH is the hour (00-23), MM\nis the minutes (00-60). SS is the optional seconds (00-61).\n\nThe time is either terminated by the literal character Z, or a timezone offset. The \"Z\"\ncharacter indicates Zulu time or UTC. The timezone offset specifies the sign s, which is + or -,\nand the difference in hours and minutes.\n"
                },
                {
                    "name": "GeneralizedTime",
                    "content": "The GeneralizedTime type encodes a GeneralizedTime value. Unlike \"UTCTime\" it represents years\nusing 4 digits, so is Y2K-compliant. It is a sub-class of \"STRING\".\n\nGeneralizedTime values must be strings like:\n\nyyyymmddHHMM[SS][.U][Z]\nor:\nyyyymmddHHMM[SS][.U]sHHMM\n\nWhere yyyy is the year, mm is the month (01-12), dd is the day (01-31), HH is the hour (00-23),\nMM is the minutes (00-60). SS is the optional seconds (00-61). U is the optional fractional\nseconds value; a comma is permitted instead of a dot before this value.\n\nThe time may be terminated by the literal character Z, or a timezone offset. The \"Z\" character\nindicates Zulu time or UTC. The timezone offset specifies the sign s, which is + or -, and the\ndifference in hours and minutes. If there is timezone specified UTC is assumed.\n"
                },
                {
                    "name": "GraphicString",
                    "content": "The GraphicString type encodes a GraphicString value. It is a sub-class of \"STRING\".\n\nVisibleString/ISO646String\nThe VisibleString type encodes a VisibleString value, which is a value using the ISO646\ncharacter set. It is a sub-class of \"STRING\".\n\nISO646String is an alternative name for VisibleString.\n"
                },
                {
                    "name": "GeneralString",
                    "content": "The GeneralString type encodes a GeneralString value. It is a sub-class of \"STRING\".\n\nUniversalString/CharacterString\nThe UniveralString type encodes a UniveralString value, which is a value using the ISO10646\ncharacter set. Each character in ISO10646 is 4-bytes wide. It is a sub-class of \"STRING\".\n\nCharacterString is an alternative name for UniversalString.\n\nBMPString\nThe BMPString type encodes a BMPString value, which is a value using the Unicode character set.\nEach character in the Unicode character set is 2-bytes wide. It is a sub-class of \"STRING\".\n"
                }
            ]
        },
        "CONSTRUCTED OPERATORS": {
            "content": "These operators are used to build constructed types, which contain values in different types,\nlike a C structure.\n\nSEQUENCE\nA SEQUENCE is a complex type that contains other types, a bit like a C structure. Elements\ninside a SEQUENCE are encoded and decoded in the order given.\n\nEncoding\nThe *value* should be a reference to an array containing another *opList* which defines the\nelements inside the SEQUENCE.\n\n$ber->encode(\nSEQUENCE => [\nINTEGER => 123,\nBOOLEAN => [ 1, 0 ],\n]\n) or die;\n\nDecoding\nThe *value* should a reference to an array that contains the *opList* which decodes the\ncontents of the SEQUENCE.\n\n$ber->decode(\nSEQUENCE => [\nINTEGER => \\$ival,\nBOOLEAN => \\@bvals,\n]\n) or die;\n\nSET\nA SET is an complex type that contains other types, rather like a SEQUENCE. Elements inside a\nSET may be present in any order.\n\nEncoding\nThe *value* is the same as for the SEQUENCE operator.\n\n$ber->encode(\nSET => [\nINTEGER => 13,\nSTRING => 'Hello',\n]\n) or die;\n\nDecoding\nThe *value* should be a reference to an equivalent *opList* to that used to encode the SET.\nThe ordering of the *opList* should not matter.\n\n$ber->decode(\nSET => [\nSTRING => \\$sval,\nINTEGER => \\$ival,\n]\n) or die;\n\nSEQUENCEOF\nA SEQUENCEOF is an ordered list of other types.\n\nEncoding\nThe *value* is a *ref* followed by an *opList*. The *ref* must be a reference to a list or a\nhash: if it is to a list, then the *opList* will be repeated once for every element in the\nlist. If it is to a hash, then the *opList* will be repeated once for every key in the hash\n(note that ordering of keys in a hash is not guaranteed by perl.)\n\nThe remaining *opList* will then usually contain *value*s which are code references. If the\n*ref* is to a list, then the contents of that item in the list are passed as the only\nargument to the code reference. If the *ref* is to a hash, then only the key is passed to\nthe code.\n\n@vals = ( [ 10, 'Foo' ], [ 20, 'Bar' ] ); # List of refs to lists\n$ber->encode(\nSEQUENCEOF => [ \\@vals,\nSEQUENCE => [\nINTEGER => sub { $[0][0] }, # Passed a ref to the inner list\nSTRING => sub { $[0][1] }, # Passed a ref to the inner list\n]\n]\n) or die;\n%hash = ( 40 => 'Baz', 30 => 'Bletch' ); # Just a hash\n$ber->decode(\nSEQUENCEOF => [ \\%hash,\nSEQUENCE => [\nINTEGER => sub { $[0] }, # Passed the key\nSTRING => sub { $hash{$[0]} }, # Passed the key\n]\n]\n);\n\nDecoding\nThe *value* must be a reference to a list containing a *ref* and an *opList*. The *ref* must\nalways be a reference to a scalar. Each value in the <opList> is usually a code reference.\nThe code referenced is called with the value of the *ref* (dereferenced); the value of the\n*ref* is incremented for each item in the SEQUENCEOF.\n\n$ber->decode(\nSEQUENCEOF => [ \\$count,\n# In the following subs, make space at the end of an array, and\n# return a reference to that newly created space.\nSEQUENCE => [\nINTEGER => sub { $ival[$[0]] = undef; \\$ival[-1] },\nSTRING => sub { $sval[$[0]] = undef; \\$sval[-1] },\n]\n]\n) or die;\n\nSETOF\nA SETOF is an unordered list. This is treated in an identical way to a SEQUENCEOF, except that\nno ordering should be inferred from the list passed or returned.\n",
            "subsections": []
        },
        "SPECIAL OPERATORS": {
            "content": "BER\nIt is sometimes useful to construct or deconstruct BER encodings in several pieces. The BER\noperator lets you do this.\n\nEncoding\nThe *value* should be another \"Convert::BER\" object, which will be inserted into the buffer.\nIf *value* is undefined then nothing is added.\n\n$tmp->encode(\nSEQUENCE => [\nINTEGER => 20,\nSTRING => 'Foo',\n]\n);\n$ber->encode(\nBER => $tmp,\nBOOLEAN => 1\n);\n\nDecoding\n*value* should be a reference to a scalar, which will contain a \"Convert::BER\" object. This\nobject will contain the remainder of the current sequence or set being decoded.\n\n# After this, ber2 will contain the encoded INTEGER B<and> STRING.\n# sval will be ignored and left undefined, but bval will be decoded. The\n# decode of ber2 will return the integer and string values.\n$ber->decode(\nSEQUENCE => [\nBER => \\$ber2,\nSTRING => \\$sval,\n],\nBOOLEAN => \\$bval,\n);\n$ber2->decode(\nINTEGER => \\$ival,\nSTRING => \\$sval2,\n);\n\nANY\nThis is like the \"BER\" operator except that when decoding only the next item is decoded and\nplaced into the \"Convert::BER\" object returned. There is no difference when encoding.\n\nDecoding\n*value* should be a reference to a scalar, which will contain a \"Convert::BER\" object. This\nobject will only contain the next single item in the current sequence being decoded.\n\n# After this, ber2 will decode further, and ival and sval\n# will be decoded.\n$ber->decode(\nINTEGER = \\$ival,\nANY => \\$ber2,\nSTRING => \\$sval,\n);\n\nOPTIONAL\nThis operator allows you to specify that an element is absent from the encoding.\n\nEncoding\nThe *value* should be a reference to another list with another *opList*. If all of the\nvalues of the inner *opList* are defined, the entire OPTIONAL *value* will be encoded,\notherwise it will be omitted.\n\n$ber->encode(\nSEQUENCE => [\nINTEGER => 16, # Will be encoded\nOPTIONAL => [\nINTEGER => undef, # Will not be encoded\n],\nSTRING => 'Foo', # Will be encoded\n]\n);\n\nDecoding\nThe contents of *value* are decoded if possible, if not then decode continues at the next\n*operator*-*value* pair.\n\n$ber->decode(\nSEQUENCE => [\nINTEGER => \\$ival1,\nOPTIONAL => [\nINTEGER => \\$ival2,\n],\nSTRING => \\$sval,\n]\n);\n\nCHOICE\nThe *opList* is a list of alternate *operator*-*value* pairs. Only one will be encoded, and only\none will be decoded.\n\nEncoding\nA scalar at the start of the *opList* identifies which *opList* alternative to use for\nencoding the value. A value of 0 means the first one is used, 1 means the second one, etc.\n\n# Encode the BMPString alternate of the CHOICE\n$ber->encode(\nCHOICE => [ 2,\nPrintableString => 'Printable',\nTeletexString   => 'Teletex/T61',\nBMPString       => 'BMP/Unicode',\nUniversalString => 'Universal/ISO10646',\n]\n) or die;\n\nDecoding\nA reference to a scalar at the start of the *opList* is used to store which alternative is\ndecoded (0 for the first one, 1 for the second one, etc.) Pass undef instead of the ref if\nyou don't care about this, or you store all the alternate values in different variables.\n\n# Decode the above.\n# Afterwards, $alt will be set to 2, $str will be set to 'BMP/Unicode'.\n$ber->decode(\nCHOICE => [ \\$alt,\nPrintableString => \\$str,\nTeletexString   => \\$str,\nBMPString       => \\$str,\nUniversalString => \\$str,\n]\n) or die;\n",
            "subsections": []
        },
        "TAGS": {
            "content": "In BER everything being encoded has a tag, a length, and a value. Normally the tag is derived\nfrom the operator - so INTEGER has a different tag from a BOOLEAN, for instance.\n\nIn some applications it is necessary to change the tags used. For example, a SET may need to\ncontain two different INTEGER values. Tags may be changed in two ways, either IMPLICITly or\nEXPLICITly. With IMPLICIT tagging, the new tag completely replaces the old tag. With EXPLICIT\ntagging, the new tag is used as well as the old tag.\n\n\"Convert::BER\" supports two ways of using IMPLICIT tagging. One method is to sub-class\n\"Convert::BER\", which is described in the next section. For small applications or those that\nthink sub-classing is just too much then the operator may be passed an arrayref. The array must\ncontain two elements, the first is the usual operator name and the second is the tag value to\nuse, as shown below.\n\n$ber->encode(\n[ SEQUENCE => 0x34 ] => [\nINTEGER => 10,\nSTRING  => \"A\"\n]\n) or die;\n\nThis will encode a sequence, with a tag value of 0x34, which will contain and integer and a\nstring which will have their default tag values.\n\nYou may wish to construct your tags using some pre-defined functions such as\n&Convert::BER::BERAPPLICATION, &Convert::BER::BERCONTEXT, etc, instead of calculating the tag\nvalues yourself.\n\nTo use EXPLICIT tagging, enclose the original element in a SEQUENCE, and just override the\nSEQUENCE's tag as above. Don't forget to set the constructed bit using\n&Convert::BER::BERCONSTRUCTOR. For example, the ASN.1 definition:\n\nFoo ::= SEQUENCE {\n[0] EXPLICIT INTEGER,\nINTEGER\n}\n\nmight be encoded using this:\n\n$ber->encode(\nSEQUENCE => [\n[ SEQUENCE => &Convert::BER::BERCONTEXT |\n&Convert::BER::BERCONSTRUCTOR | 0 ] => [\nINTEGER => 10,\n],\nINTEGER => 11,\n],\n) or die;\n",
            "subsections": []
        },
        "SUB-CLASSING": {
            "content": "For large applications where operators with non default tags are used a lot the above mechanism\ncan be very error-prone. For this reason, \"Convert::BER\" may be sub-classed.\n\nTo do this the sub-class must call a static method \"define\". The arguments to \"define\" is a list\nof arrayrefs. Each arrayref will define one new operator. Each arrayref contains three values,\nthe first is the name of the operator, the second is how the data is encoded and the third is\nthe tag value. To aid with the creation of these arguments \"Convert::BER\" exports some variables\nand constant subroutines.\n\nFor each operator defined by \"Convert::BER\", or a \"Convert::BER\" sub-class, a scalar variable\nwith the same name is available for import, for example $INTEGER is available from\n\"Convert::BER\". And any operators defined by a new sub-class will be available for import from\nthat class. One of these variables may be used as the second element of each arrayref.\n\n\"Convert::BER\" also exports some constant subroutines that can be used to create the tag value.\nThe subroutines exported are:\n\nBERBOOLEAN\nBERINTEGER\nBERBITSTR\nBEROCTETSTR\nBERNULL\nBEROBJECTID\nBERSEQUENCE\nBERSET\n\nBERUNIVERSAL\nBERAPPLICATION\nBERCONTEXT\nBERPRIVATE\nBERPRIMITIVE\nBERCONSTRUCTOR\n\n\"Convert::BER\" also provides a subroutine called \"bertag\" to calculate an integer value that\nwill be used to represent a tag. For tags with values less than 30 this is not needed, but for\ntags >= 30 then tag value passed for an operator definition must be the result of \"bertag\"\n\n\"bertag\" takes two arguments, the first is the tag class and the second is the tag value.\n\nUsing this information a sub-class of Convert::BER can be created as shown below.\n\npackage Net::LDAP::BER;\n\nuse Convert::BER qw(/^(\\$|BER)/);\n\nuse strict;\nuse vars qw($VERSION @ISA);\n\n@ISA = qw(Convert::BER);\n$VERSION = \"1.00\";\n\nNet::LDAP::BER->define(\n\n# Name            Type      Tag\n########################################\n\n[ REQUNBIND     => $NULL,\nBERAPPLICATION                   | 0x02 ],\n\n[ REQCOMPARE    => $SEQUENCE,\nBERAPPLICATION | BERCONSTRUCTOR | 0x0E ],\n\n[ REQABANDON    => $INTEGER,\nbertag(BERAPPLICATION, 0x10) ],\n);\n\nThis will create a new class \"Net::LDAP::BER\" which has three new operators available. This\nclass then may be used as follows\n\n$ber = new Net::LDAP::BER;\n\n$ber->encode(\nREQUNBIND => 0,\nREQCOMPARE => [\nREQABANDON => 123,\n]\n);\n\n$ber->decode(\nREQUNBIND => \\$var,\nREQCOMPARE => [\nREQABANDON => \\$num,\n]\n);\n\nWhich will encode or decode the data using the formats and tags defined in the \"Net::LDAP::BER\"\nsub-class. It also helps to make the code more readable.\n\nDEFINING NEW PACKING OPERATORS\nAs well as defining new operators which inherit from existing operators it is also possible to\ndefine a new operator and how data is encoded and decoded. The interface for doing this is still\nchanging but will be documented here when it is done. To be continued ...\n",
            "subsections": []
        },
        "LIMITATIONS": {
            "content": "Convert::BER cannot support tags that contain more bits than can be stored in a scalar variable,\ntypically this is 32 bits.\n\nConvert::BER cannot support items that have a packed length which cannot be stored in 32 bits.\n",
            "subsections": []
        },
        "BUGS": {
            "content": "The \"SET\" decode method fails if the encoded order is different to the *opList* order.\n",
            "subsections": []
        },
        "AUTHOR": {
            "content": "Graham Barr <gbarr@pobox.com>\n\nSignificant POD updates from Chris Ridd <Chris.Ridd@messagingdirect.com>\n",
            "subsections": []
        },
        "COPYRIGHT": {
            "content": "Copyright (c) 1995-2000 Graham Barr. All rights reserved. This program is free software; you can\nredistribute it and/or modify it under the same terms as Perl itself.\n",
            "subsections": []
        }
    },
    "summary": "Convert::BER - ASN.1 Basic Encoding Rules",
    "flags": [],
    "examples": [],
    "see_also": []
}