dSjddlmZddlmZmZmZmZddlmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZddlmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dZ%dFdZ&dGdZ'dHd Z(d Z)d Z*d Z+d Z,dZ-dZ.dZ/dZ0dZ1dZ2dZ3dZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;dZd Z?d!Z@d"ZAd#ZBd$ZCd%ZDd&ZEd'ZFd(ZGd)ZHd*ZId+ZJe,d,fd-ZKd.ZLd/ZMd0ZNd1ZOd2ZPdId3ZQd4ZRd5ZSd6ZTd7ZUeVfd8ZWd9ZXd:ZYd;ZZd<Z[d=Z\ dJd?Z]e,d,d>fd@Z^dd>e%d>dfdAZ_dBZ`dKdCZadLdDZbdEZcy>)M)int2byte)BitStreamReaderBitStreamWriter encode_bin decode_bin)Struct MetaField StaticField FormatFieldOnDemandPointerSwitchValue RepeatUntil MetaArraySequenceRangeSelectPass SizeofErrorBufferedRestreamReconfig) BitIntegerAdapterPaddingAdapter ConstAdapterCStringAdapterLengthValueAdapterIndexingAdapterPaddedStringAdapter FlagsAdapter StringAdapterMappingAdaptercHt|r t||St||S)a* A field consisting of a specified number of bytes. :param str name: the name of the field :param length: the length of the field. the length can be either an integer (StaticField), or a function that takes the context as an argument and returns the length (MetaField) )callabler r )namelengths ;/usr/lib/python3/dist-packages/elftools/construct/macros.pyFieldr)s&v&&4((c6tt||||||S)a BitFields, as the name suggests, are fields that operate on raw, unaligned bits, and therefore must be enclosed in a BitStruct. Using them is very similar to all normal fields: they take a name and a length (in bits). :param str name: name of the field :param int length: number of bits in the field, or a function that takes the context as its argument and returns the length :param bool swapped: whether the value is byte-swapped :param bool signed: whether the value is signed :param int bytesize: number of bits per byte, for byte-swapping >>> foo = BitStruct("foo", ... BitField("a", 3), ... Flag("b"), ... Padding(3), ... Nibble("c"), ... BitField("d", 5), ... ) >>> foo.parse("\xe1\x1f") Container(a = 7, b = False, c = 8, d = 31) >>> foo = BitStruct("foo", ... BitField("a", 3), ... Flag("b"), ... Padding(3), ... Nibble("c"), ... Struct("bar", ... Nibble("d"), ... Bit("e"), ... ) ... ) >>> foo.parse("\xe1\x1f") Container(a = 7, b = False, bar = Container(d = 15, e = 1), c = 8) )swappedsignedbytesize)rr))r&r'r,r-r.s r(BitFieldr/s'H U40  r*c2ttd|||S)aa padding field (value is discarded) * length - the length of the field. the length can be either an integer, or a function that takes the context as an argument and returns the length * pattern - the padding pattern (character/byte) to use. default is b"\x00" * strict - whether or not to raise an exception is the actual padding pattern mismatches the desired pattern. default is False. N)patternstrict)rr))r'r2r3s r(Paddingr4Hs  %f- r*c\tt|dt|t|d|S)a@ A flag. Flags are usually used to signify a Boolean value, and this construct maps values onto the ``bool`` type. .. note:: This construct works with both bit and byte contexts. .. warning:: Flags default to False, not True. This is different from the C and Python way of thinking about truth, and may be subject to change in the future. :param str name: field name :param int truth: value of truth (default 1) :param int falsehood: value of falsehood (default 0) :param bool default: default value (default False) rTF)default)SymmetricMappingr)r)r&truth falsehoodr7s r(Flagr;Vs-& E$N))<= r*ct|dS)z1a 1-bit BitField; must be enclosed in a BitStructrr/r&s r(Bitr?q D! r*ct|dS)z1a 4-bit BitField; must be enclosed in a BitStructr=r>s r(NibblerCtr@r*ct|dS)z2an 8-bit BitField; must be enclosed in a BitStructr=r>s r(OctetrFwr@r*ct|ddS)z"unsigned, big endian 8-bit integer>Br r>s r(UBInt8rK{ tS# &&r*ct|ddS)z#unsigned, big endian 16-bit integerrHHrJr>s r(UBInt16rO~rLr*ct|ddS)z#unsigned, big endian 32-bit integerrHLrJr>s r(UBInt32rRrLr*ct|ddS)z#unsigned, big endian 64-bit integerrHQrJr>s r(UBInt64rUrLr*ct|ddS)z signed, big endian 8-bit integerrHbrJr>s r(SBInt8rXrLr*ct|ddS)z!signed, big endian 16-bit integerrHhrJr>s r(SBInt16r[rLr*ct|ddS)z!signed, big endian 32-bit integerrHlrJr>s r(SBInt32r^rLr*ct|ddS)z!signed, big endian 64-bit integerrHqrJr>s r(SBInt64rarLr*ct|ddS)z%unsigned, little endian 8-bit integers r(ULInt8rdrLr*ct|ddS)z&unsigned, little endian 16-bit integerrcrNrJr>s r(ULInt16rfrLr*ct|ddS)z&unsigned, little endian 32-bit integerrcrQrJr>s r(ULInt32rhrLr*ct|ddS)z&unsigned, little endian 64-bit integerrcrTrJr>s r(ULInt64rjrLr*ct|ddS)z#signed, little endian 8-bit integerrcrWrJr>s r(SLInt8rlrLr*ct|ddS)z$signed, little endian 16-bit integerrcrZrJr>s r(SLInt16rnrLr*ct|ddS)z$signed, little endian 32-bit integerrcr]rJr>s r(SLInt32rprLr*ct|ddS)z$signed, little endian 64-bit integerrcr`rJr>s r(SLInt64rrrLr*ct|ddS)z(unsigned, native endianity 8-bit integer=rIrJr>s r(UNInt8rurLr*ct|ddS)z)unsigned, native endianity 16-bit integerrtrNrJr>s r(UNInt16rwrLr*ct|ddS)z)unsigned, native endianity 32-bit integerrtrQrJr>s r(UNInt32ryrLr*ct|ddS)z)unsigned, native endianity 64-bit integerrtrTrJr>s r(UNInt64r{rLr*ct|ddS)z&signed, native endianity 8-bit integerrtrWrJr>s r(SNInt8r}rLr*ct|ddS)z'signed, native endianity 16-bit integerrtrZrJr>s r(SNInt16rrLr*ct|ddS)z'signed, native endianity 32-bit integerrtr]rJr>s r(SNInt32rrLr*ct|ddS)z'signed, native endianity 64-bit integerrtr`rJr>s r(SNInt64rrLr*ct|ddS)z-big endian, 32-bit IEEE floating point numberrHfrJr>s r(BFloat32rrLr*ct|ddS)z0little endian, 32-bit IEEE floating point numberrcrrJr>s r(LFloat32rrLr*ct|ddS)z3native endianity, 32-bit IEEE floating point numberrtrrJr>s r(NFloat32rrLr*ct|ddS)z-big endian, 64-bit IEEE floating point numberrHdrJr>s r(BFloat64rrLr*ct|ddS)z0little endian, 64-bit IEEE floating point numberrcrrJr>s r(LFloat64rrLr*ct|ddS)z3native endianity, 64-bit IEEE floating point numberrtrrJr>s r(NFloat64rrLr*ctrt|}|Stfd|}|j|j|S)a Repeats the given unit a fixed number of times. :param int count: number of times to repeat :param ``Construct`` subcon: construct to repeat >>> c = Array(4, UBInt8("foo")) >>> c.parse("\x01\x02\x03\x04") [1, 2, 3, 4] >>> c.parse("\x01\x02\x03\x04\x05\x06") [1, 2, 3, 4] >>> c.build([5,6,7,8]) '\x05\x06\x07\x08' >>> c.build([5,6,7,8,9]) Traceback (most recent call last): ... construct.core.RangeError: expected 4..4, found 5 cSN)ctxcounts r(zArray..sEr*)r%r _clear_flag FLAG_DYNAMIC)rsubconcons` r(ArrayrsE(v& J)62 (() Jr*r'c btt|jtfd|dS)zan array prefixed by a length field. * subcon - the subcon to be repeated * length_field - a construct returning an integer c"|jSrr>r length_fields r(rzPrefixedArray..sc,"3"34r*Fnested)rrr&r)rrs `r( PrefixedArrayrs1   4f =  r*c(ddlm}t|||S)N)maxsize)sysrr)mincountrrs r( OpenRanger s 7F ++r*ctd|S)a Repeats the given unit one or more times. :param ``Construct`` subcon: construct to repeat >>> from construct import GreedyRange, UBInt8 >>> c = GreedyRange(UBInt8("foo")) >>> c.parse("\x01") [1] >>> c.parse("\x01\x02\x03") [1, 2, 3] >>> c.parse("\x01\x02\x03\x04\x05\x06") [1, 2, 3, 4, 5, 6] >>> c.parse("") Traceback (most recent call last): ... construct.core.RangeError: expected 1..2147483647, found 0 >>> c.build([1,2]) '\x01\x02' >>> c.build([]) Traceback (most recent call last): ... construct.core.RangeError: expected 1..2147483647, found 0 rrrs r( GreedyRanger s4 Q r*ctd|S)a Repeats the given unit zero or more times. This repeater can't fail, as it accepts lists of any length. :param ``Construct`` subcon: construct to repeat >>> from construct import OptionalGreedyRange, UBInt8 >>> c = OptionalGreedyRange(UBInt8("foo")) >>> c.parse("") [] >>> c.parse("\x01\x02") [1, 2] >>> c.build([]) '' >>> c.build([1,2]) '\x01\x02' rrrs r(OptionalGreedyRanger)s& Q r*c8t|j|tS)zran optional construct. if parsing fails, returns None. * subcon - the subcon to optionally parse or build )rr&rrs r(OptionalrBs &++vt ,,r*cd}d}|j|js,|j|krt|tt |}|St |tt|}|S)zzconverts the stream to bits, and passes the bitstream to subcon * subcon - a bitwise construct (usually BitField) i c.|dzr td||dz S)Nzsize must be a multiple of 8)r)r's r(resizerzBitwise..resizerOs! A:= 2c8j|zz zSr)_sizeof)rmodulusrs r( padlengthzAligned..padlengthhs!6>>#.89WDDr*)r2Fr) ValueErrorSeqOfOner&r4)rrr2rs`` r(Alignedr`sE {/99E FKK  W- r*c6tt|g|i|dS)za sequence of one element. only the first element is meaningful, the rest are discarded * name - the name of the sequence * args - subconstructs * kw - any keyword arguments to Sequence r)index)rr)r&argskws r(rrts  8D64626 BBr*cDt|j||jS)zRembeds a struct into the enclosing struct. * subcon - the struct to embed )rr& FLAG_EMBEDrs r(Embeddedr}s FKK):): ;;r*ct||S)zcrenames an existing construct * newname - the new name * subcon - the subcon to rename )r)newnamers r(Renamers GV $$r*c"t|fdS)zcreates an alias for an existing element in a struct * newname - the new name * oldname - the name of an existing element c|Srr)roldnames r(rzAlias..s c'lr*)r)rrs `r(Aliasrs 2 33r*cbtd|jD}t|||||S)adefines a symmetrical mapping: a->b, b->a. * subcon - the subcon to map * mapping - the encoding mapping (a dict); the decoding mapping is achieved by reversing this mapping * default - the default value to use when no mapping is found. if no default value is given, and exception is raised. setting to Pass would return the value "as is" (unmapped) c3*K|] \}}||f ywrr).0kvs r( z#SymmetricMapping..s?tq!QF?s)encodingdecoding encdefault decdefault)dictitemsr#)rmappingr7reversed_mappings r(r8r8s6?w}}?? &#  r*c Dt|||jdtS)aa set of named values mapping. * subcon - the subcon to map * kw - keyword arguments which serve as the encoding mapping * _default_ - an optional, keyword-only argument that specifies the default value to use when the mapping is undefined. if not given, and exception is raised when the mapping is undefined. use `Pass` to pass the unmapped value as-is _default_)r8popNotImplementedrrs r(Enumrs FB{N(K LLr*c t||S)za set of flag values mapping. * subcon - the subcon to map * kw - keyword arguments which serve as the encoding mapping )r!rs r( FlagsEnumrs  ##r*c.t|gfd|DS)za struct of aligned fields * name - the name of the struct * subcons - the subcons that make up this structure * kw - keyword arguments to pass to Aligned: 'modulus' and 'pattern' c36K|]}t|fiywr)r)rscrs r(rz AlignedStruct..s>'"++>s)r)r&subconsrs `r( AlignedStructrs $ ?>g> ??r*c,tt|g|S)z{a struct of bitwise fields * name - the name of the struct * subcons - the subcons that make up this structure )rr)r&rs r( BitStructrs 6$)) **r*c>tttdg|S)zian embedded BitStruct. no name is necessary. * subcons - the subcons that make up this structure N)rrr)rs r(EmbeddedBitStructrs 8F42'23 44r*NcVtt|||}|t||||}|S)ae A configurable, fixed-length string field. The padding character must be specified for padding and trimming to work. :param str name: name :param int length: length, in bytes :param str encoding: encoding (e.g. "utf8") or None for no encoding :param str padchar: optional character to pad out strings :param str paddir: direction to pad out strings; one of "right", "left", or "both" :param str trim: direction to trim strings; one of "right", "left" >>> from construct import String >>> String("foo", 5).parse("hello") 'hello' >>> >>> String("foo", 12, encoding = "utf8").parse("hello joh\xd4\x83n") u'hello joh\u0503n' >>> >>> foo = String("foo", 10, padchar = "X", paddir = "right") >>> foo.parse("helloXXXXX") 'hello' >>> foo.build("hello") 'helloXXXXX' r)padcharpaddirtrimdir)r"r)r )r&r'rrrrrs r(Stringrs5: dF+h ?C!#wv Jr*c `ttt|tdfd|S)a- A length-prefixed string. ``PascalString`` is named after the string types of Pascal, which are length-prefixed. Lisp strings also follow this convention. The length field will appear in the same ``Container`` as the ``PascalString``, with the given name. :param str name: name :param ``Construct`` length_field: a field which will store the length of the string :param str encoding: encoding (e.g. "utf8") or None for no encoding >>> foo = PascalString("foo") >>> foo.parse("\x05hello") 'hello' >>> foo.build("hello world") '\x0bhello world' >>> >>> foo = PascalString("foo", length_field = UBInt16("length")) >>> foo.parse("\x00\x05hello") 'hello' >>> foo.build("hello") '\x00\x05hello' datac"|jSrr>rs r(rzPascalString..s#l.?.?*@r*r)r"rrr))r&rrs ` r( PascalStringrs78  Tf@A   r*c Nt|ttfd||S)aH A string ending in a terminator. ``CString`` is similar to the strings of C, C++, and other related programming languages. By default, the terminator is the NULL byte (b``0x00``). :param str name: name :param iterable terminators: sequence of valid terminators, in order of preference :param str encoding: encoding (e.g. "utf8") or None for no encoding :param ``Construct`` char_field: construct representing a single character >>> foo = CString("foo") >>> foo.parse(b"hello\x00") b'hello' >>> foo.build(b"hello") b'hello\x00' >>> foo = CString("foo", terminators = b"XYZ") >>> foo.parse(b"helloX") b'hello' >>> foo.parse(b"helloY") b'hello' >>> foo.parse(b"helloZ") b'hello' >>> foo.build(b"hello") b'helloX' c |vSrr)objr terminatorss r(rzCString..?s  );r*)rr)rrr)r&rr char_fields ` r(CStringrs.@ $ ;Z H#  r*c*t|fd||dS)aan if-then-else conditional construct: if the predicate indicates True, `then_subcon` will be used; otherwise `else_subcon` * name - the name of the construct * predicate - a function taking the context as an argument and returning True or False * then_subcon - the subcon that will be used if the predicate returns True * else_subcon - the subcon that will be used if the predicate returns False c&t|Sr)bool)r predicates r(rzIfThenElse..RsD3$8r*r6)r)r&r  then_subcon else_subcons ` r( IfThenElser Is" $8  r*c Nt|j||tdfdS)aan if-then conditional construct: if the predicate indicates True, subcon will be used; otherwise, `elsevalue` will be returned instead. * predicate - a function taking the context as an argument and returning True or False * subcon - the subcon that will be used if the predicate returns True * elsevalue - the value that will be used should the predicate return False. by default this value is None. elsevaluecSrr)rrs r(rzIf..esyr*)r r&r)r rrs `r(IfrYs) fkk k01 r*c2tt||d|S)a$an on-demand pointer. * offsetfunc - a function taking the context as an argument and returning the absolute stream position * subcon - the subcon that will be parsed from the `offsetfunc()` stream position on demand * force_build - see OnDemand. by default True. F)advance_stream force_build)r r ) offsetfuncrrs r(OnDemandPointerrls  GJ/! r*c@ttdt||Sr)rr)len)rs r(Magicrys dCI. 55r*)FFrE)r0F)rrF)rBr0)NNrightrr)T)d lib.py3compatrlibrrrrcorerr r r r r rrrrrrrrrrrradaptersrrrrrrr r!r"r#r)r/r4r;r?rCrFrKrOrRrUrXr[r^rardrfrhrjrlrnrprrrurwryr{r}rrrrrrrrrrrrrrrrrrrrrrr8rrrrrrrrr rrrrr*r(rs#=====FFF ))V 6''''''''''''''''''''''''''''''6*0)9 , 8 2- 0(C< %41?" M$@+5>E !F%+8$4t$L&T1~&X & 6r*