o v&i @sdZddlmZddlZddlZddlmZddlmZm Z m Z ddl m Z m Z mZd#d d Zd$ddZedddZeddZeddZGdddZee e eefZeeefZd%ddZd&d!d"ZdS)'z!Bytecode analysis for coverage.py) annotationsN)CodeType)IterableMappingOptional)TArcTLineNoTOffsetcoderreturnIterable[CodeType]ccsF|g}|r!|}|jD] }t|tr||q |V|sdSdS)z,Iterate over all the code objects in `code`.N)pop co_consts isinstancerappend)r stackcrW/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/coverage/bytecode.py code_objectss    rop_namesstrset[int]cs(fdd|D}|sJd||S)zMake a set of opcodes from instruction names. The names might not exist in this version of Python, skip those if not. cs h|] }tj|rqSr)disopmapget).0nameoprr "s zop_set..z At least one opcode must exist: r)ropsrrrop_setsr" JUMP_BACKWARDJUMP_BACKWARD_NO_INTERRUPT JUMP_FORWARD RETURN_VALUERETURN_GENERATORNOP NOT_TAKENc@s,eZdZdZdddZdd d dddZdS)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 NonecCsD||_i|_d}t|D]}||j|j<q |dusJ|j|_dSN)r instsrget_instructionsoffset max_offset)selfr instrrr__init__Ds  zInstructionWalker.__init__rTstart_at follow_jumpsr5r r6boolIterable[dis.Instruction]ccszt}|}||jdkr;||vrdS|||j|}r.|V|r.|jtvr.|j}q|d7}||jdks dSdS)z} Yield instructions starting from `start_at`. Follow unconditional jumps if `follow_jumps` is true. N)setr0addr-ropcode ALWAYS_JUMPS jump_target)r1r5r6seenr/r2rrrwalkOs zInstructionWalker.walkN)r rr r+)r5r r6r7r r8)__name__ __module__ __qualname____doc__r3rArrrrr*;s   r* multiline_mapMapping[TLineNo, TLineNo] TBranchTrailsc stdd}tjddD]U}|jsq|jtvrq|jdur%qdfd d }tt }|||j dd|||jd|||j <| D]\}}|D] }||| |qYqSq|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. cSs ttSr,) collections defaultdictr;rrrr~s zbranch_trails..Fr6NtrailsTBranchTrailsOneSourcer5r r r+cst}d}j|ddD]4}||j|j}|dur!||}|r+|kr+|}n|jr5|jtvr5n |jt vr@j }nq |durP||f |dSt|d<dS)NTr4) r;rAr<r/ line_numberrr?r=r>RETURNSco_firstlinenoupdate)rMr5 inst_offsetsto_lineinst2l2r from_lineiwalkerrFrradd_one_branch_trails&    z+branch_trails..add_one_branch_trailr:)r5)rMrNr5r r r+) rIrJr*rAr?r=r>rOrr;r/itemsrR) r rF the_trailsr2rZrMarcoffsetsr/rrWr branch_trailshs,    r_dict[TOffset, TOffset]cCsTi}t|}|jddD]}|jtvr|j||j<q |jtvr'|jd||j<q |S)zMake a map of unconditional bytecodes jumping to others. Only include bytecodes that do no work and go to another bytecode. FrLr:)r*rAr=r>r?r/NOPS)r jumpsrYr2rrr always_jumpss  rc)r rr r )rrr r)r rrFrGr rH)r rr r`)rE __future__rrIrtypesrtypingrrrcoverage.typesrrr rr"r>rPrar*dictr;rNrHr_rcrrrrs6     )  P