archive.git - Gitblit

Ë  
hñúhJ<ãóædZddlZddlZddlmZddlmZddlmZe    edej«Z
defdZejejzfd    efd
Zd    edefdZej$sd ZeZdZdZdZdZdZnqej4sdZdZdZdZdZdZed«ZdZnMd ZeZej8rdZndZdZej8rdZndZdZej:red«ZdZned«ZdZedezd zezd!zezd"zezd#zezd$zezd%zezd&zezd'z«Zed(ezd)zezd*z«Zd+efd,Z d-ed.ed/efd0Z!d-ed.ed/e"fd1Z#d.ed/e"fd2Z$d8d3e%d.ed/e&fd4Z'd.ed/e&fd5Z(d6efd7Z)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_opmapÚxcóNtjtt|g««S)zG
    Get a regex-escaped opcode byte from its human readable name.
    )ÚreÚescapeÚbytesÚopmap)rs úNH:\Change_password\venv_build\Lib\site-packages\PyInstaller/depend/bytecode.pyÚ_instruction_to_regexr)sô99UE !H:Ó&Ó'Ð'óÚpatterncót|t«sJtjdd|«}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|dj««S)Né)rÚdecode)Úms r ú<lambda>z bytecode_regex.<locals>.<lambda>@sÔ'¨¨!©¯©« Ó6r)Úflags)Ú
isinstancerr    ÚsubÚcompile)rrs  r Úbytecode_regexr0s@ôguÔ%Ð%Ð%ôffØÙ6ØóGô
::g UÔ+Ð+rÚstringc#óøKt|t«sJt|«}|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_stringÚfinditerÚstart)rrÚmatchesÚmatchs    r r r FsèøôfeÔ$Ð$Ð$Ü % fÓ -FØ×ÑvÓ&GØ
Øò    EØ{{}qÑ  AÒ%àð"×*Ñ*¨6°5·;±;³=À1Ñ3DÓEÙð    ð ðù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ó|S©N©©Úbytecodes r rrpsØrs#`EXTENDED_ARG`|`EXTENDED_ARG_QUICK`s"`EXTENDED_ARG``EXTENDED_ARG_QUICK`s`PRECALL`|`CALL_FUNCTION_EX`s(`CACHE`.)|(..)có.tjd|«S©Ns\2©Ú_cache_instruction_filterrr's r rrsÜ(×,Ñ,¨V°XÓ>Ð>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 óÜ,×0Ñ0°¸ÓBÐBrcó.tjd|«Sr*r+r's r rr¥r.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|dddd«S)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.
    rNrÚbig)ÚintÚ
from_bytes)r0s r Úextended_argumentsr5Ûs ô>>-¨¨¨1¨Ñ-¨uÓ5Ð5rÚrawÚcodeÚreturncólt|«}|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_ATTRÚLOAD_SMALL_INTÚLOAD_CONST_IMMORTALÚLOAD_FAST_BORROW)    r5rÚco_varnamesÚ    co_constsrÚis_py311Úco_namesÚis_py312Úis_py314)r6r7Úindexs   r ÚloadrIés&ô
 sÓ#Eð
2w%Ñ$Ò$à×Ñ Ñ&Ð&à
2w%Ñ%Ò%à~~eÑ$Ð$ä 3r7¤e¨MÑ&:Ò:à}}U aZÑ(Ð(Ü 3r7¤e¨KÑ&8Ò8à}}U aZÑ(Ð(Ü 3r7¤eÐ,<Ñ&=Ò=àÜ 3r7¤eÐ,AÑ&BÒBð~~eÑ$Ð$Ü 3r7¤eÐ,>Ñ&?Ò?ð×Ñ Ñ&Ð&à==ÑÐrcóftj|«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_bytecodeÚfindallrI)r6r7Úis   r ÚloadsrNs)ô$:×#AÑ#AÀ#Ó#FÖGaDDMÒGÐGùÒGs.cóàg}tt|j«D]Î}|j«\}}}}t    ||«}t||«}dj |g|z«}t||«}|dtdk(rBt|«}|dk7rqt|«dk7st|dt«st|d«}nt|«}    |    t|«k7r¼|j||f«Ð|S)zJ
    Scan a code object for all function calls on constant arguments.
    ú.rÚCALL_FUNCTION_EXr)r Ú_call_function_bytecodeÚco_codeÚgroupsrIrNÚjoinrr5ÚlenrÚtupleÚlistÚappend)
r7Úoutr#Ú function_rootÚmethodsÚargsÚ function_callÚfunctionrÚ    arg_counts
          r Úfunction_callsrasõð
 CäÔ1°4·<±<Ó@ò%Ø6;·l±l³nÑ3 w  mô]¨DÓ1 Ü Ó&Ø88]O¨gÑ5Ó6äT4Ó ØÑuÐ%7Ñ8Ò8Ü& }Ó5EØzàô4yA~¤Z°°Q±¼Ô%?ØÜQ=Dä*¨=Ó9IàC IÒ%àà

HdÐ#Õ$ð;%ð>JrÚsearchcó|i}||vr:||«||<|jD] }t|t«st|||«"|S)zm
    Apply a search function to a code object, recursing into child code objects (function definitions).
    )rCrrÚsearch_recursively)rbr7Ú_memoÚconsts    r rdrdBsSð }ØØ5ÑÙTldØ^^ò    9EÜ%¤Õ*Ü" 6¨5°%Õ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ô
n¨dÓ3Ð3rÚ    full_namec#ójK|jd«}|rdj|«|dd}|ryyw)aÏList 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)riÚpartss  r Ú    any_aliasrmXs7èøð& OOCÓ EÙ
ØhhuoÒØab    ôùs.3±3r%)*Ú__doc__Údisr    ÚtypesrÚtypingrÚPyInstallerrÚgetattrrÚstrrÚVERBOSEÚDOTALLrrr rDÚ_OPCODES_EXTENDED_ARGÚ_OPCODES_EXTENDED_ARG2Ú_OPCODES_FUNCTION_GLOBALÚ_OPCODES_FUNCTION_LOADÚ_OPCODES_FUNCTION_ARGSÚ_OPCODES_FUNCTION_CALLrrFr,rGÚis_py313rRrKr5rIrXrNraÚcallableÚdictrdrhrmr&rr ú<module>rsÏðñó"Û    ÝÝåñ
    \ 3§9¡9Ó-ð(Só(ð*,¯©°b·i±iÑ)?ñ,Eó,ð,gð uóðBà.ÐØ2ÐØHÐØ:ÐØ-ÐØQÐóà    ð
DÐØCÐØHÐØ:ÐØ-ÐØ=Ðñ
!/Ð/BÓ CÐó?ð
/ÐØ2ÐØ à#_Ñ à#LÐ Ø,ÐØ ð"YÑà!1ÐØ:ÐðÙ$2Ð3UÓ$VÐ!ó    Cñ%3Ð3FÓ$GÐ!ò    Cñ
)ðð
'ñ'ð
*ñð*ñ *ð-ñ  ð)ñ )ð,ñð'ñ'ð*ñð,*ñ-*ð,-ñ-ð.(ñ/(ð.+ñ/ð<(ñ=(ð<+ ñ= ð>&ñ?&ð>)ñ?!ó#ÐñL(ðà%ñ&ð)
ñ
ð
 #ñ#ð
&ñóÐð6 eó6ð$ eð$ 8ð$ ¨ó$ ðNHuðHHðH¨óHð&ð& dó&ñRxð¨xðÈóð4 8ð4°ó4ðôr