L-PhdZddlmZddlZddlmZddlmZmZddl m Z ddl m Z m Z dd ZddZedddZeddZGddZeee ee fZee eefZddZdS)z!Bytecode analysis for coverage.py) annotationsN)CodeType)IterableOptional)Iterator)TArcTOffsetcoderreturnIterator[CodeType]c#K|g}|rP|}|jD],}t|tr||-|V|NdSdS)z,Iterate over all the code objects in `code`.N)pop co_consts isinstancerappend)r stackcs Q/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/coverage/bytecode.py code_objectsrs~ FE yy{{  A!X&&  Q  op_namesstrset[int]c fd|DS)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#&S)disopmapget).0nameops r zop_set..#s1 C C C4cimmD.A.A(A CB C C Crr)rr"s @rop_setr$s D C C C8 C C CCr JUMP_BACKWARDJUMP_BACKWARD_NO_INTERRUPT JUMP_FORWARD RETURN_VALUERETURN_GENERATORc*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 rr Nonec||_i|_d}tj|D]}||j|j<|J|j|_dS)N)r instsrget_instructionsoffset max_offset)selfr insts r__init__zInstructionWalker.__init__;sY 57 (.. + +D&*DJt{ # #+rrT)start_at follow_jumpsr5r r6boolIterable[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. N)setr1addr.ropcode ALWAYS_JUMPS jump_target)r2r5r6seenr0r3s rwalkzInstructionWalker.walkFsuut***~~ HHV   z~~f---t  DK<$?$?!-F aKFt*******rN)r rr r,)r5r r6r7r r8)__name__ __module__ __qualname____doc__r4rBrrrr+r+1sW & & & &&'Trr+ TBranchTrailscxi}tdD]}|js |jtvr|j#d fd }||jd z ||j g}|||j<|D]1}|d D]&}||vrg||<|||'2|S) a Calculate branch trails for `code`. 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. F)r6Nr5r r TBranchTrailcNt}d}|D]f}||j|jr|jkr |j}n0|jr|jtvrn|jtvr j }ng|||ffStdfS)Nr5) r<rBr=r0 line_numberr@r>r?RETURNSco_firstlineno)r5 inst_offsetsto_lineinst2r from_lineiwalkers rwalk_one_branchz&branch_trails..walk_one_branch}s),LG x88    ...$):i)G)G#/GE&EL ,L,LE\W,,#22GE-"#i%999uud{"rr;rKr)r5r r rI)r+rBr@r>r?rLr0r) r the_trailsr3rTtrailstrailr0rRrSs ` @@r branch_trailsrX_s4 !#J%%G % 00/1/1   ;, & & $    # # # # # # # #, OT[1_ 5 5 5 OT%5 6 6 6 #) 4;  1 1E( 1 1++)+Jv&6"))%0000 1 1 r)r rr r )rrr r)r rr rG)rF __future__rrtypesrtypingrrcollections.abcrcoverage.typesrr rr$r?rMr+tupler<rIdictlistrGrXrrrrasR('"""""" %%%%%%%%$$$$$$((((((((    DDDDv   &!3 4 4''''''''TS\8D>12 Wd<001 CCCCCCr