hiJ<dZddlZddlZddlmZddlmZddlmZe edejZ de fdZ ejejzfd efd Zd ed efd Zej$sd ZeZdZdZdZdZdZnqej4sdZdZdZdZdZdZedZdZnMd ZeZej8rdZndZdZej8rdZndZdZej:r edZdZn edZdZedezd zezd!zezd"zezd#zezd$zezd%zezd&zezd'zZed(ezd)zezd*zZd+efd,Z d-ed.ed/e fd0Z!d-ed.ed/e"fd1Z#d.ed/e"fd2Z$d8d3e%d.ed/e&fd4Z'd.ed/e&fd5Z(d6e fd7Z)y)9aX Tools for searching bytecode for key statements that indicate the need for additional resources, such as data files and package metadata. By *bytecode* I mean the ``code`` object given by ``compile()``, accessible from the ``__code__`` attribute of any non-builtin function or, in PyInstallerLand, the ``PyiModuleGraph.node("some.module").code`` attribute. The best guide for bytecode format I have found is the disassembler reference: https://docs.python.org/3/library/dis.html This parser implementation aims to combine the flexibility and speed of regex with the clarity of the output of ``dis.dis(code)``. It has not achieved the 2nd, but C'est la vie... The biggest clarity killer here is the ``EXTENDED_ARG`` opcode which can appear almost anywhere and therefore needs to be tiptoed around at every step. If this code needs to expand significantly, I would recommend an upgrade to a regex-based grammar parsing library such as Reparse. This way, little steps like unpacking ``EXTENDED_ARGS`` can be defined once then simply referenced forming a nice hierarchy rather than copied everywhere its needed. N)CodeType)Pattern)compat _all_opmapxcNtjtt|gS)zG Get a regex-escaped opcode byte from its human readable name. )reescapebytesopmap)rs GC:\des-py\Monitor\venv\Lib\site-packages\PyInstaller/depend/bytecode.py_instruction_to_regexr)s 99UE!H:& ''patternct|tsJtjdd|}tj||S)a A regex-powered Python bytecode matcher. ``bytecode_regex`` provides a very thin wrapper around :func:`re.compile`. * Any opcode names wrapped in backticks are substituted for their corresponding opcode bytes. * Patterns are compiled in VERBOSE mode by default so that whitespace and comments may be used. This aims to mirror the output of :func:`dis.dis`, which is far more readable than looking at raw byte strings. s`(\w+)`c:t|djS)N)rdecode)ms r z bytecode_regex..@s'! 6r)flags) isinstancer r subcompile)rrs r bytecode_regexr0s@ gu %% %ff6G ::gU ++rstringc#Kt|tsJt|}|j|} |D]A}|j dzdk(r||j||j dz}nyHw)a Call ``pattern.finditer(string)``, but remove any matches beginning on an odd byte (i.e., matches where match.start() is not a multiple of 2). This should be used to avoid false positive matches where a bytecode pair's argument is mistaken for an opcode. rrN)rr _cleanup_bytecode_stringfinditerstart)rrmatchesmatchs r r r Fs fe $$ $ %f -Fv&G  E{{}q A% "**65;;=13DE   sA8A:s`EXTENDED_ARG`s%`LOAD_NAME`|`LOAD_GLOBAL`|`LOAD_FAST`s`LOAD_ATTR`|`LOAD_METHOD`s `LOAD_CONST`s0`CALL_FUNCTION`|`CALL_METHOD`|`CALL_FUNCTION_EX`c|SNbytecodes r rrpsrs#`EXTENDED_ARG`|`EXTENDED_ARG_QUICK`s"`EXTENDED_ARG``EXTENDED_ARG_QUICK`s`PRECALL`|`CALL_FUNCTION_EX`s(`CACHE`.)|(..)c.tjd|SNs\2_cache_instruction_filterrr's r rrs(,,VX>>rs8`LOAD_NAME`|`LOAD_GLOBAL`|`LOAD_FAST`|`LOAD_FAST_BORROW`s `LOAD_ATTR`s3`LOAD_CONST`|`LOAD_SMALL_INT`|`LOAD_CONST_IMMORTAL`s`CALL`|`CALL_FUNCTION_EX`s(`CACHE`.)|(`PUSH_NULL`.)|(..)c.tjd|S)Ns\3r+r's r rr,00B Brc.tjd|Sr*r+r's r rrr.rs # Matches `global_function('some', 'constant', 'arguments')`. # Load the global function. In code with >256 of names, this may require extended name references. ( (?:(?:s).)* (?:(?:s).) ) # For foo.bar.whizz(), the above is the 'foo', below is the 'bar.whizz' (one opcode per name component, each # possibly preceded by name reference extension). ( (?: (?:(?:s).)* (?:s). )* ) # Load however many arguments it takes. These (for now) must all be constants. # Again, code with >256 constants may need extended enumeration. ( (?: (?:(?:s).)* (?:s). )* ) # Call the function. If opcode is CALL_FUNCTION_EX, the parameter are flags. For other opcodes, the parameter # is the argument count (which may be > 256). ( (?:(?:s).)* (?:s ). ) s:( # Arbitrary number of EXTENDED_ARG pairs. (?:(?:sG).)* # Followed by some other instruction (usually a LOAD). [^s]. ) extended_argsc:tj|ddddS)aQ Unpack the (extended) integer used to reference names or constants. The input should be a bytecode snippet of the following form:: EXTENDED_ARG ? # Repeated 0-4 times. LOAD_xxx ? # Any of LOAD_NAME/LOAD_CONST/LOAD_METHOD/... Each ? byte combined together gives the number we want. rNrbig)int from_bytes)r0s r extended_argumentsr5s  >>-1-u 55rrawcodereturnclt|}|dtdk(r|j|S|dtdk(r|j|Stj r!|dtdk(r|j |dz Stjr!|dtdk(r|j |dz Stjr|dtdk(r|Stjr|dtdk(r|j|Stjr|dtd k(r|j|S|j |S) z3 Parse an (extended) LOAD_xxx instruction. LOAD_FAST LOAD_CONST LOAD_GLOBALr LOAD_ATTRLOAD_SMALL_INTLOAD_CONST_IMMORTALLOAD_FAST_BORROW) r5r co_varnames co_constsris_py311co_namesis_py312is_py314)r6r7indexs r loadrIs& s #E  2w% $$&& 2w% %%~~e$$ 3r7eM&::}}UaZ(( 3r7eK&88}}UaZ(( 3r7e,<&==  3r7e,A&BB~~e$$ 3r7e,>&??&& == rcftj|Dcgc]}t||c}Scc}w)z Parse multiple consecutive LOAD_xxx instructions. Or load() in a for loop. May be used to unpack a function's parameters or nested attributes ``(foo.bar.pop.whack)``. )_extended_arg_bytecodefindallrI)r6r7is r loadsrNs) $:#A#A##F GaDDM GG Gs.cg}tt|jD]}|j\}}}}t ||}t ||}dj |g|z}t ||}|dtdk(rBt|}|dk7rqt|dk7st|dtst|d}nt|} | t|k7r|j||f|S)zJ Scan a code object for all function calls on constant arguments. .rCALL_FUNCTION_EXr)r _call_function_bytecodeco_codegroupsrIrNjoinr r5lenrtuplelistappend) r7outr# function_rootmethodsargs function_callfunctionr arg_counts r function_callsras C14<<@%6;lln3 wm ]D1 &88]Og56T4   u%78 8&}5Ez4yA~ZQ%?Q=D*=9ICI% Hd#$;%> Jrsearchc|i}||vr:||||<|jD] }t|tst|||"|S)zm Apply a search function to a code object, recursing into child code objects (function definitions). )rCrrsearch_recursively)rbr7_memoconsts r rdrdBsS } 5Tld ^^ 9E%*"65%8 9 Lrc"tt|S)z Scan a code object for function calls on constant arguments, recursing into function definitions and bodies of comprehension loops. )rdra)r7s r recursive_function_callsrhPs nd 33r full_namec#jK|jd}|rdj||dd}|ryyw)aList possible aliases of a fully qualified Python name. >>> list(any_alias("foo.bar.wizz")) ['foo.bar.wizz', 'bar.wizz', 'wizz'] This crudely allows us to capture uses of wizz() under any of :: import foo foo.bar.wizz() :: from foo import bar bar.wizz() :: from foo.bar import wizz wizz() However, it will fail for any form of aliases and quite likely find false matches. rPrN)splitrU)ripartss r any_aliasrmXs7& OOC E hhuoab  s.33r%)*__doc__disr typesrtypingr PyInstallerrgetattrr strrVERBOSEDOTALLr rr rD_OPCODES_EXTENDED_ARG_OPCODES_EXTENDED_ARG2_OPCODES_FUNCTION_GLOBAL_OPCODES_FUNCTION_LOAD_OPCODES_FUNCTION_ARGS_OPCODES_FUNCTION_CALLrrFr,rGis_py313rRrKr5rIrXrNracallabledictrdrhrmr&rr rs"  \399-(S(*,bii)?,E,,guB.2H:-Q  DCH:-= !//B C? /2 #_ #L , "Y!1:$23U$V! C%33F$G! C ) ' ' *  * * - ) ),''*,*-*,--.(/(.+/<(=(<+ = >&?&>)?!#L(%&)  # # &  6e 6$ e$ 8$ $ NHuHHHH&&d&R x x  4844r