0j!@dZddlmZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z mZmZGdd Zd"dZd#dZedddZeddZeddZGddZee e eefZeeefZd$dZd%d!ZdS)&z!Bytecode analysis for coverage.py) annotationsN)IterableMapping)CodeType)Optional)TArcTLineNoTOffsetcDeZdZdZdddddd Zdd ZddZddZddZdS) ByteParserz3Parse bytecode to understand the structure of code.N)codetextfilenamer CodeType | Noner str | NonerreturnNonecJ||Jt||pddd}||_dS)NzexecT) dont_inherit)compiler )selfr rrs P/home/lighthouse/health/venv/lib64/python3.11/site-packages/coverage/bytecode.py__init__zByteParser.__init__s; <###4!7ZdSSSD Iterable[ByteParser]c>d|DS)a|Iterate over all the code objects nested within this one. The iteration includes `self` as its first value. We skip code objects named `__annotate__` since they are deferred annotations that usually are never run. If there are errors in the annotations, they will be caught by type checkers or other tools that use annotations. c3LK|]}|jdk t|V dS) __annotate__)r N)co_namer ).0cs r z,ByteParser._child_parsers..+s:__q19P^C^C^ """C^C^C^C^__r) code_objects)rs r_child_parserszByteParser._child_parsers s%`_D,=,=,?,?____rIterable[CodeType]c#K|jg}|rP|}|jD],}t|tr||-|V|NdSdS)z,Iterate over all the code objects in `code`.N)r pop co_consts isinstancerappend)rstackr r"s rr$zByteParser.code_objects-s  99;;D^ $ $a**$LLOOOJJJ     rIterable[TLineNo]c#VK|jD] \}}}|r|V dS)zyYield the line numbers possible in this code object. Uses co_lines() to produce a sequence: l0, l1, ... N)r co_lines)r_lines r _line_numberszByteParser._line_numbers9sG ),,..  JAq$    rc#lK|D]}|Ed{VdS)zFind the statements in `self.code`. Produce a sequence of line numbers that start statements. Recurses into all code objects reachable from `self.code`. N)r%r2)rbps rfind_statementszByteParser.find_statementsBsT%%'' * *B'')) ) ) ) ) ) ) ) ) * *r)r rrrrrrr)rr)rr&)rr-) __name__ __module__ __qualname____doc__rr%r$r2r5rrr r s== !%#       ` ` ` `     * * * * * *rr r rrdict[TOffset, TLineNo]cvi}|D]!\}}}|t||dD]}|||<"|S)z6Make a dict mapping byte code offsets to line numbers.N)r/range)r b2lbstartbendlinenoboffsets rbytes_to_linesrDNsW C $ &&f   q11 & &%G Jrop_namesstrset[int]cBfd|D}|s Jd||S)zMake a set of opcodes from instruction names. The names might not exist in this version of Python, skip those if not. cVh|]%}tj|x#&Sr:)disopmapget)r!nameops r zop_set..]s1 B B B$SY]]4-@-@'@r B2 B B Brz At least one opcode must exist: r:)rEopsrNs @rop_setrQXsA C B B B( B B BC ===8===== Jr JUMP_BACKWARDJUMP_BACKWARD_NO_INTERRUPT JUMP_FORWARD RETURN_VALUERETURN_GENERATORNOP NOT_TAKENc*eZdZdZddZddd ddZdS)InstructionWalkera]Utility to step through trails of instructions. We have two reasons to need sequences of instructions from a code object: First, in strict sequence to visit all the instructions in the object. This is `walk(follow_jumps=False)`. Second, we want to follow jumps to understand how execution will flow: `walk(follow_jumps=True)`. r rrrc||_i|_d}tj|D]}||j|j<|J|j|_dSN)r instsrJget_instructionsoffset max_offset)rr insts rrzInstructionWalker.__init__sY 57 (.. + +D&*DJt{ # #+rrTstart_at follow_jumpsrcr rdboolIterable[dis.Instruction]c#Kt}|}||jdzkrh||vrdS|||j|x}r|V|r|jt vr|j}a|dz }||jdzkfdSdS)z} Yield instructions starting from `start_at`. Follow unconditional jumps if `follow_jumps` is true. r=N)setr`addr]rLopcode ALWAYS_JUMPS jump_target)rrcrdseenr_ras rwalkzInstructionWalker.walksuut***~~ HHV   z~~f---t  DK<$?$?!-F aKFt*******rN)r rrr)rcr rdrerrf)r6r7r8r9rror:rrrZrZvsW & & & &&'TrrZ multiline_mapMapping[TLineNo, TLineNo] TBranchTrailsc tjd}t dD]}|js |jt vr|j #  d fd }tjt}|||j d z |||j |||j <| D]+\}}|D]#}||| |$,|S)a Calculate branch trails for `code`. `multiline_map` maps line numbers to the first line number of a multi-line statement. Instructions can have a jump_target, where they might jump to next. Some instructions with a jump_target are unconditional jumps (ALWAYS_JUMPS), so they aren't interesting to us, since they aren't the start of a branch possibility. Instructions that might or might not jump somewhere else are branch possibilities. For each of those, we track a trail of instructions. These are lists of instruction offsets, the next instructions that can execute. We follow the trail until we get to a new source line. That gives us the arc from the original instruction's line to the new source line. c4tjtSr\) collections defaultdictrir:rrzbranch_trails..s @WX[@\@\rFrdNtrailsTBranchTrailsOneSourcercr rrct}d}|dD]v}||j|j}| ||}|r |kr|}n0|jr|jtvrn|jtvr j }nw|||f |dSt|d<dS)NTrb) rirorjr_ line_numberrLrmrkrlRETURNSco_firstlinenoupdate) ryrc inst_offsetsto_lineinst2l2r from_lineiwalkerrps radd_one_branch_trailz+branch_trails..add_one_branch_trails *-LG xdKK    ...&>&**2r22B" // GE&EL ,L,LE\W,,#22GE-" 7+,33LAAAAA"uut rr=)rc)ryrzrcr rr) rurvrZrormrkrlr|rLrir_itemsr) r rp the_trailsrarryarcoffsetsr_rrs `` @@r branch_trailsrsi,!, 78\8\ ] ]J%%G % 003838   ;, & & $   !%%i;;  % % % % % % % % %6*5)@)E)EVdkAo>>>>Vd.>????"( 4; #LLNN 8 8LC! 8 86"3'..w7777 8 8 rdict[TOffset, TOffset]ci}t|}|dD]@}|jtvr|j||j< |jt vr|jdz||j<A|S)zMake a map of unconditional bytecodes jumping to others. Only include bytecodes that do no work and go to another bytecode. Frxr=)rZrorkrlrmr_NOPS)r jumpsrras r always_jumpsrsw E%%G % 0011 ;, & &!%!1E$+   [D !%qE$+  Lr)r rrr;)rErFrrG)r rrprqrrr)r rrr)r9 __future__rrurJcollections.abcrrtypesrtypingrcoverage.typesrr r r rDrQrlr}rrZdictrirzrrrrr:rrrs('"""""" --------1111111111:*:*:*:*:*:*:*:*zv   &   v  &&&&&&&&Rhtnc'l:;W445 MMMM`      r