X-PhjdZddlmZddlZddlZddlmZddlmZm Z ddl m Z m Z m Z mZmZmZmZmZddlmZddlmZdd lmZdd lmZdd lmZmZdd lmZm Z dd l!m"Z"ddl#m$Z$m%Z%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1m2Z2ddl3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@ddlAmBZBmCZCmDZDddlEmFZFmGZGddlHmIZIddlJmKZKddlLmMZMddlNmOZOddlPmQZQmRZRddlSmTZTddlUmVZVddlWmXZXdd lYmZZZdd!l[m\Z\dd"l]m^Z^dd#l_m`Z`dd$lambZbecede eeefZfedefZgedeceeeefZhGd%d&ZiGd'd(eZj dqdrd7Zkdsd@ZldtdAZmdudDZndvdHZodwdKZpdxdPZqdydSZrdzdUZsd{dZZtd|d]Zud}d_ZvGd`daZwe dbZxd~dfZyddjZzddmZ{ddpZ|dS)zHGenerate C code for a Python C extension module from Python source code.) annotationsN)Iterable)OptionalTypeVar) BuildResult BuildSourceStatebuild compute_hashcreate_metastoreget_cache_namessorted_components) CompileError)FileSystemCache)MypyFile)Options)PluginReportConfigContext) hash_digest json_dumps)c_string_initializer)EmitterEmitterContextHeaderDeclarationc_array_initializer)generate_classgenerate_class_type_decl)generate_native_functionnative_function_header) generate_legacy_wrapper_functiongenerate_wrapper_functionlegacy_wrapper_function_headerwrapper_function_header)Literals) MODULE_PREFIXPREFIXRUNTIME_C_FILESTOP_LEVEL_NAMETYPE_VAR_PREFIXshared_lib_nameshort_id_from_name)Errors)FuncIR)ModuleIR ModuleIRsdeserialize_modules) DeserMaps LoadLiteral)RType)build_ir)Mapper) load_type_map) NameGenerator exported_name)CompilerOptions)do_copy_propagation)insert_exception_handling)do_flag_elimination)lower_ir)insert_ref_count_opcodes) insert_spills)insert_uninit_checksceZdZdZd dZd S) MarkedDeclarationz(Add a mark, useful for topological sort. declarationrmarkboolreturnNonec"||_d|_dS)NF)rCrD)selfrCrDs X/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypyc/codegen/emitmodule.py__init__zMarkedDeclaration.__init__as& N)rCrrDrErFrG)__name__ __module__ __qualname____doc__rKrLrJrBrB^s.22rLrBc4eZdZdZdfd ZddZddZxZS) MypycPluginaPlugin for making mypyc interoperate properly with mypy incremental mode. Basically the point of this plugin is to force mypy to recheck things based on the demands of mypyc in a couple situations: * Any modules in the same group must be compiled together, so we tell mypy that modules depend on all their groupmates. * If the IR metadata is missing or stale or any of the generated C source files associated missing or stale, then we need to recompile the module so we mark it as stale. optionsrcompiler_optionsr9groupsGroupsrFrGct|i|_|D]/\}}td|D}|D]}||f|j|<0||_t ||_dS)Nc3$K|] }|jV dSNmodule.0sources rJ z'MypycPlugin.__init__..xs$AAvV]AAAAAArL)superrK group_mapsortedrUr metastore) rIrTrUrVsourcesnamemodulesid __class__s rJrKzMypycPlugin.__init__rs !!!BD# 5 5MGTAAAAAAAG 5 5&*G_r"" 5!1)'22rLctxr#tuple[str | None, list[str]] | Nonec&|j|j|j}}}||jvrdS|s |j|St |||j\}}}t |||j} |j|}|j|} n#t$rYdSwxYwtj | } t|| dkrdS| d D]\}} ttj|jj|d5} | } dddn #1swxYwYn#t$rYdSwxYwt| }| |krdS|j|S)N meta_hash src_hashesrb)rhpathis_checkrbr rTget_ir_cache_namerdreadFileNotFoundErrorjsonloadsritemsopenosjoinrU target_dir)rIrjrhrprq meta_path_ir_path meta_jsonir_jsonir_datahashfcontents real_hashs rJreport_config_datazMypycPlugin.report_config_datas !VSXs|(D T^ # #4 &>"% %*"dDLAA 1a#Bdl;; ++I66In))'22GG    44   *W%% y ! !W[%9 9 94 ",/5577  JD$ "',,t'<'GNNPTUU(YZ vvxxH((((((((((((((($   ttt #H--Iy  tt!~b!!sH!4B B$#B$68E.E EE EE E E*)E*filerlist[tuple[int, str, int]]cfd|j|jdgfdDS)Ncg|]}d|dfS) rQ)r^rhs rJ z3MypycPlugin.get_additional_deps..sXXXR XXXrL)rbgetfullname)rIrs rJget_additional_depszMypycPlugin.get_additional_depss5XXt~'9'9$-$PR'T'TUV'WXXXXrL)rTrrUr9rVrWrFrG)rjrrFrk)rrrFr)rMrNrOrPrKrr __classcell__)ris@rJrSrSfsx   3 3 3 3 3 3/"/"/"/"bYYYYYYYYrLrSrelist[BuildSource]rTrrUr9rVrWfscacheFileSystemCache | None alt_lib_path str | NonerFrc |js Jdt||||t|||g}|jrt |j|S)Nz!strict_optional must be turned on)rerTrr extra_plugins)strict_optionalr rSerrorsr)rerTrUrVrrresults rJparse_and_typecheckrsp  "GG$GGGG !"7,.s$-B-Baf-B-B-B-B-B-BrLr)verboseprintformatrzr4graphtypes num_errorsvaluesclassesenv_user_function functionsr@r;r>r?r=r:r<) rrrrUrrgenv_user_functionsr\clsfns rJcompile_scc_to_irrs,E n##DII-B-Bc-B-B-B$B$BCCDDDsFL&,@PRXYYG 1..""@@> @ @C$ @.s 5552fl2&555rLcHg|]}|jjv|j|jSrQ)rhrbtree)r^strs rJrz)compile_modules_to_ir..s1WWWR&:J1J1Jrw1J1J1J1JrLc34K|]}|jjvVdSrZ)managerrechecked_modulesrs rJr`z(compile_modules_to_ir..s-MM2Bfn>>MMMMMMrL)r1rrallload_scc_from_cacherupdate) rrrUr deser_ctxrgr scc_statestreesfreshscc_irs `` rJcompile_modules_to_irrs"b!!IG!.. # #5555555 WWWW:WWW  MMMMMMMMM  # vvy A A A A&uff>NPVWWF NN6 " " " " NrLrg'dict[str | None, list[tuple[str, str]]]c fd|D}td|D}i}|D]K\}} fd|D} | sg|| <t| || |j||} | || <L|S)zCompile a collection of ModuleIRs to C source text. Returns a dictionary mapping group names to a list of (file name, file text) pairs. cZi|]'\}}|D]}|jj|jj (SrQ)r\rxpath)r^rer}r_rs rJ z#compile_ir_to_c..-sT GQ   v|FM28rLc,g|]\}}d|DS)cg|] }|j SrQr[r]s rJrz.compile_ir_to_c...3s@@@fFM@@@rLrQ)r^rer}s rJrz#compile_ir_to_c..3s+ZZZZWa@@@@@ZZZrLcHi|]}|jv |j|jSrQr[)r^r_rgs rJrz#compile_ir_to_c..9s;   }'' M76=1'''rL)r7GroupGeneratorrbgenerate_c_for_modules) rVrgrrrU source_pathsnamesctext group_sources group_name group_modules generators `` rJcompile_ir_to_cr!s L ZZSYZZZ [ [E68E%+ ? ?! z    '     "E*  " <V5EuN^  &<<>>j LrLrhstrrpcXt|||\}}}|ddS)Nz .meta.jsonz.ir.json)r replace)rhrprTr|r}s rJrrrrIs/%b$88OIq!   \: 6 66rLstater cBt|j|j|jSrZ)rrrhrrT)rs rJget_state_ir_cache_namerNs UXu{EM B BBrLrbdict[str, str | None]rrGcji}|D]\}}d|D||<|D]\}}|j|} t|| j|jj\} } } |jj| } n#t$rYcwxYwt| } | t| |||d}|jj | t||jjdS)aWrite out the cache information for modules. Each module has the following cache information written (which is in addition to the cache information written by mypy itself): * A serialized version of its mypyc IR, minus the bodies of functions. This allows code that depends on it to use these serialized data structures when compiling against it instead of needing to recompile it. (Compiling against a module requires access to both its mypy and mypyc data structures.) * The hash of the mypy metadata cache file for the module. This is used to ensure that the mypyc cache and the mypy cache are in sync and refer to the same version of the code. This is particularly important if mypyc crashes/errors/is stopped after mypy has written its cache but before mypyc has. * The hashes of all of the source file outputs for the group the module is in. This is so that the module will be recompiled if the source outputs are missing. c4i|]\}}|t|SrQ)r )r^rdatas rJrzwrite_cache..ns&IIIZT4l400IIIrL)irrmrnN)rwrr rrrTrdrsOSErrorr serializerwritercommit)rgrrbrhashesrffilesrhr\rr|r} meta_datanewpathrs rJ write_cacherRsM4F{{}}JJ eII5IIIt mmooEE F \" )"bh8NOO 1a 055i@@II    H *"--""$$$Y// 2/    &&w 70C0CDDDD N##%%%%%s7B B$#B$rjr1cffd|D}t||}t||||S)zfLoad IR for an SCC of modules from the cache. Arguments and return are as compile_scc_to_ir. c i|]\}|jtjjjt j|jd]S)r)rrurvrrdrsrr)r^krs rJrz'load_scc_from_cache..sk  DJ N $ ) )*A&,qzBZ*[*[ \ \  rL)r0r6)rrrrj cache_datargs ` rJrrsU J "*c22G&#s### NrL,tuple[ModuleIRs, list[FileContents], Mapper]c^d|D}t|}|jjddd|jjt ||||}|jdkrigtifSt|||||t||||fd|D|fS)a@Compile Python module(s) to the source of Python C extension modules. This generates the source code for the "shared library" module for each group. The shim modules are generated in mypyc.build. Each shared library module provides, for each module in its group, a PyCapsule containing an initialization function. Additionally, it provides a capsule containing an export table of pointers to all of the group's functions and static variables. Arguments: result: The BuildResult from the mypy front-end compiler_options: The compilation options errors: Where to report any errors encountered groups: The groups that we are compiling. See documentation of Groups type above. Returns the IR of the modules and a list containing the generated files for each group. c.i|]\}}|D] }|j| SrQr[)r^grouplib_namer_s rJrz(compile_modules_to_c..s.[[[_UHUZ[[6[[[[rLzN)r\scoperTrc&g|] \}}|SrQrQ)r^r}rfrs rJrz(compile_modules_to_c..s!777WQU4[777rL) r5rrset_filerTrrrr)rrUrrVrbrrgrs @rJcompile_modules_to_crs*\[[[[I I  F N""$dFN4J#$FF4DfMMG 12vbzz!! FGVV=M N NEE222 7777777 ??rLrr-emitterrc8tt|j|dd|jj||j<|jtkrt||j rTtt||j d|jjt| |j z<dStt||j d|jjt| |j z<dSdSN;T needs_export)rrdeclcontext declarationsnative_function_namerfr(is_fastcall_supported capi_versionr#rr&cnamer")rrs rJgenerate_function_declarationrsJ[ !"'7 3 3666TKKKGO !=!=bg!F!FG w.  W%9 : : M^*2w}==@@@NNGO ("((7=2I2I)I J J JN_1"gmDDGGGNNGO ("((7=2I2I)I J J J ! rLrrfcpd|vr||d|dS||d|S)zHGiven a C decl and its name, modify it to be a declaration to a pointer.(z(*)*)r)rrfs rJ pointerizer sE d{{||D,t,,,///||D*d**---rLrcvtj|dddS)z>Given a group name, return the relative directory path for it..Nr)ryseprzsplit)rs rJ group_dirrs- 6;;z'',,SbS1 2 22rLceZdZd;dZeddZd?dZ d@dZ d@dZ dAd Z dBd!Z dCd#Zd$d%dDd)ZdEd*ZdFd+ZdEd,ZdGd/ZdHd2ZdId5ZdJd7ZdKd:Zd$S)Lrrgdict[str, ModuleIR]rdict[str, str]rrrbrrr7rUr9rFrGc||_||_t||||_||_g|_||_|du|_||_|j |_ dS)aGenerator for C source for a compilation group. The code for a compilation group contains an internal and an external .h file, and then one .c if not in multi_file mode or one .c file per module if in multi_file mode.) Arguments: modules: (name, ir) pairs for each module in the group source_paths: Map from module names to source file paths group_name: The name of the group (or None if this is single-module compilation) group_map: A map of modules to their group names names: The name generator for the compilation multi_file: Whether to put each module in its own source file regardless of group structure. N) rgrrrr simple_initsruse_shared_librU multi_file)rIrgrrrbrrUs rJrKzGroupGenerator.__init__sa0 (%eZCC  46$(4 0*5rLrcB|jrdt|jzndS)Nr})rr8rIs rJ group_suffixzGroupGenerator.group_suffixs#7;Ns]4?3333BNrLct|jr0dt|jddzndS)Nr}r rr)rr8r rs rJshort_group_suffixz!GroupGenerator.short_group_suffix s7FJo]s]4?#8#8#=#=b#ABBBB[]]rLlist[tuple[str, str]]c g}|jo|j}|jD]&}|jD]}t ||jj't|j}|j j r#tD]}| d|d| d|j d| d|j d|}||jD]\}}|rPt|j}| d|j d| d|j d||||||||j||jD]} | jrt-| |||||||jD]}| t1|||j|||jt6krd| t9||jrt=|||j||t?|||j|||rMd|j !|d}|"|d#|j$ft|j} | d |j%d | d |j%d | d | d t|j} | d|j%d | d|j%d | d | d | d|j d| | d| |jD]s\}}|&||j'| |jD]} tQ| || | |)||j*| |jD]}tW|| ttY|jj-D]} t]| } t]| /dd}| 0d1tdj3#ti| d|dd| d| d|5}|}|6|| |D]s}|j7r| n| }|j7sP|j0d|j8dg|j8ddR|j9r|j0|j9T|j0|j8d|j0|j8t|j:r+|;| ||<|| d| d|j:rti|j:nd}|tdj3#|d|j dd#|j$ftdj3#|d|j dd#| j$ftdj3#|d|j dd#| j$fgzS)Nz #include ""z#include "__nativez.h"z#include "__native_internal __native_z.crz#ifndef MYPYC_NATIVE_Hz#define MYPYC_NATIVEz#include z#include z#ifndef MYPYC_NATIVE_INTERNALz#define MYPYC_NATIVE_INTERNALzint CPyGlobalsInit(void);r rz #include <{}>z.hzstruct export_table_z exports_rzextern rrz#endif__native__native_internal)=rrrgrrcollect_literalsrliteralsrrUinclude_runtime_filesr' emit_linergenerate_literal_tablesrwdeclare_moduledeclare_internal_globalsdeclare_importsimportsr is_ext_classrgenerate_module_defrrrfr(rrr!r r private_nameappendrz fragmentsrdeclare_finals final_namesrdeclare_type_varstype_var_namesrrc group_depsr8r  emit_linesrryrprtoposort_declarationsgenerate_globals_initis_typerdefnrgenerate_export_tablegenerate_shared_lib_init)rI file_contentsrr\r base_emitterrfr module_nameclext_declarationsrlibelib short_lib sorted_declsrCdecls output_dirs rJrz%GroupGenerator.generate_c_for_modules s% (!@!@X;CSTUTVTVCWXXXX#:&G& (8999&G& (8999  +"2333 ? 3  & &'7 A A A  ) )' 2 2 2""8,,,x(((37?JYt///  Z)OD4K)O)O)OPP)**   Z)XT=T)X)X)XYY .//   Z)OD4K)O)O)OPP(233   rLc|jj}|d|zdt |}|dd|t |}|dd|t |}|dd|t| }|dd |t| }|dd |t| }|d d |t| }|d d |dS)aGenerate tables containing descriptions of Python literals to construct. We will store the constructed literals in a single array that contains literals of all types. This way we can refer to an arbitrary literal by its index. zPyObject *[%d] CPyStaticszconst char * const [] CPyLit_Str initializer CPyLit_Bytes CPyLit_Intzconst double [] CPyLit_FloatCPyLit_Complexz const int [] CPyLit_TupleCPyLit_FrozenSetN) rr$declare_global num_literalsc_string_array_initializerencoded_str_valuesencoded_bytes_valuesencoded_int_valuesrencoded_float_valuesencoded_complex_valuesencoded_tuple_valuesencoded_frozenset_values) rIr$init_str init_bytesinit_int init_floats init_complex init_tupleinit_frozensets rJr'z&GroupGenerator.generate_literal_tabless<( ,x/D/D/F/FF UUU-h.I.I.K.KLL 3\xXXX/0M0M0O0OPP  3^Q[\\\-h.I.I.K.KLL 3\xXXX)(*G*G*I*IJJ  -~;WWW*8+J+J+L+LMM  -/?\ZZZ()F)F)H)HII  NN SSS,X-N-N-P-PQQ N,>N[[[[[rL decl_emitterr code_emitterc|jj}|dd|jd|D]G\}}|jr;|td|j |H|d|dd|jd|D]%\}}|jr|d|d &|dd S) aGenerate the declaration and definition of the group's export struct. To avoid needing to deal with deeply platform specific issues involving dynamic library linking (and some possibly insurmountable issues involving cyclic dependencies), compiled code accesses functions and data in other compilation groups via an explicit "export struct". Each group declares a struct type that contains a pointer to every function and static variable it exports. It then populates this struct and stores a pointer to it in a capsule stored as an attribute named 'exports' on the group's shared library's python module. On load, a group's init function will import all of its dependencies' exports tables using the capsule mechanism and copy the contents into a local copy of the table (to eliminate the need for a pointer indirection when accessing it). Then, all calls to functions in another group and accesses to statics from another group are done indirectly via the export table. For example, a group containing a module b, where b contains a class B and a function bar, would declare an export table like: struct export_table_b { PyTypeObject **CPyType_B; PyObject *(*CPyDef_B)(CPyTagged cpy_r_x); CPyTagged (*CPyDef_B___foo)(PyObject *cpy_r_self, CPyTagged cpy_r_y); tuple_T2OI (*CPyDef_bar)(PyObject *cpy_r_x); char (*CPyDef___top_level__)(void); }; that would be initialized with: static struct export_table_b exports = { &CPyType_B, &CPyDef_B, &CPyDef_B___foo, &CPyDef_bar, &CPyDef___top_level__, }; To call `b.foo`, then, a function in another group would do `exports_b.CPyDef_bar(...)`. rzstruct export_tablez { };zstatic struct export_tablez exports = {&,N) rrr6rrwrr&r rzr)rIrdrerFrfrs rJr;z$GroupGenerator.generate_export_tables!X$1$P$:K$P$P$PQQQ++-- O OJD$  O&&z$))DI2F2F'M'MNNNt$$$$aAR$a$a$abbb++-- 4 4JD$  4&&{4{{{333t$$$$$rLrc|jJ||dt |jddddt |jddd d d d d dddddd|dt |jddddddddd |jD]_}t|}|d|dd|t |j|dddd|dddddd `t|j j D]}t|}|dt |d||t |d|d ddd!|"d|d d#d$d%ddS)&aGenerate the init function for a shared library. A shared library contains all of the actual code for a compilation group. The init function is responsible for creating Capsules that wrap pointers to the initialization function of all the real init functions for modules in this shared library as well as the export table containing all of the exported functions and values from all the modules. These capsules are stored in attributes of the shared library. NzPyMODINIT_FUNC PyInit_{}(void)r r{zQstatic PyModuleDef def = {{ PyModuleDef_HEAD_INIT, "{}", NULL, -1, NULL, NULL }};zint res;zPyObject *capsule;zPyObject *tmp;zstatic PyObject *module;z if (module) {zPy_INCREF(module);zreturn module;}zmodule = PyModule_Create(&def);zif (!module) {z goto fail;rz6capsule = PyCapsule_New(&exports, "{}.exports", NULL);zif (!capsule) {z9res = PyObject_SetAttrString(module, "exports", capsule);zPy_DECREF(capsule);zif (res < 0) {zextern PyObject *CPyInit_z(void);z@capsule = PyCapsule_New((void *)CPyInit_{}, "{}.init_{}", NULL);z+res = PyObject_SetAttrString(module, "init_z ", capsule);zGtmp = PyImport_ImportModule("{}"); if (!tmp) goto fail; Py_DECREF(tmp);zHstruct export_table_{} *pexports_{} = PyCapsule_Import("{}.exports", 0);zif (!pexports_) {zDmemcpy(&exports_{group}, pexports_{group}, sizeof(exports_{group}));)rfail:zPy_XDECREF(module); return NULL;) rr&r6rr*r rgr8rcrr5)rIrmodrfregroups rJr<z'GroupGenerator.generate_shared_lib_inits*** , 3 30066s;;B?   cjj#DO44   &    -    -   2  D K K00      G !     <  C %%D   9D999RYY/$/::D"PdPPP%      DL344  E"5))F   Y``#E**[aaFOE$:$:.---V]] ^     +W6K^]`aaaaarLc|dddddd|d|jD] \}}||d|d!d }|d |d d d |ddd dS)Nrzint CPyGlobalsInit(void)rlzstatic int is_initialized = 0;zif (is_initialized) return 0;z CPy_Init(); = rzbCPyLit_Str, CPyLit_Bytes, CPyLit_Int, CPyLit_Float, CPyLit_Complex, CPyLit_Tuple, CPyLit_FrozenSetz&if (CPyStatics_Initialize(CPyStatics, z) < 0) {z return -1;rmzis_initialized = 1;z return 0;)r6r&r)rIrsymbolfixuprs rJr8z$GroupGenerator.generate_globals_initOs  &  , +      -(((!. 6 6MFE   44E444 5 5 5 5u FV F F F VY    0+sCCCCCrLr?r\r.c |j|}|d|d|jD]}|j|jt krt|j|jj |j }t||j rd}nd}|d |||jt||d|d ||d |d d d |dddd|dd ||jsd|d}ndt%|d}||d|d|||} |d| dd| dd| dd|| d|d d!| d"d#|d$| d%|d&|} || d'| dd!| d"d#g} |jD]v} || } | | | jrC|d( | )|d*| d+d#w|d,d#||||d-|d| d|d.d/| dd0|jD]c\}}|||}|||d12||}||d3|dd| D]}|d/|d|d4|ddS)5zFEmit the PyModuleDef struct for a module and the module init function.zstatic PyMethodDef zmodule_methods[] = {N METH_FASTCALL METH_VARARGSzY{{"{name}", (PyCFunction){prefix}{cname}, {flag} | METH_KEYWORDS, NULL /* docstring */}},)rfrprefixflagz{NULL, NULL, 0, NULL}rhzstatic struct PyModuleDef z module = {zPyModuleDef_HEAD_INIT,rz",zNULL, /* docstring */z9-1, /* size of per-interpreter state of the module,zD or -1 if the module keeps state in global variables. */module_methodszPyMODINIT_FUNC PyInit_z(void)zPyObject *CPyInit_rlzPyObject* modname = NULL;zif (rnz Py_INCREF(z);zreturn rrmz = PyModule_Create(&zmodule);z if (unlikely(z == NULL)) goto fail;z-modname = PyObject_GetAttrString((PyObject *)z, "__name__");globalsz = PyModule_GetDict(zT{t} = (PyTypeObject *)CPyType_FromTemplate((PyObject *){t}_template, NULL, modname);)tzif (unlikely(!z))zif (CPyGlobalsInit() < 0)zPy_DECREF(modname);roz Py_CLEAR(zPy_CLEAR(modname);T)is_xdecrtrp)rr.r&r class_namerfr(r+r shortnamelinerrrrr&r6rr8module_internal_static_name static_namertype_struct_namer/ is_generatedgenerate_top_level_callr2 emit_dec_refc_undefined_value)rIrr?r\ module_prefixrrfr{rC module_staticmodule_globals type_structsr@ type_structtyprundefrs rJr-z"GroupGenerator.generate_module_defds  22;?? T TTTUUU"  B}(BG~,E,E%bgrw/@"'JJD$R)=>> &&%   .&d"((7=*A*A&W[&\\      1222$  C C C C $     # G R , , ,    " RF;FFFKKQ}[/I/IQQQK;,,,5666 88gNN  &= & & & * * * * &m & & &       I I- I I I 5M 5 5 5     YM Y Y Y   !,,Y DD D D= D D D 6N 6 6 6    #% . W WB!22266K    , , , W""@@F@U@U""#CK#C#C#CEUVVV68HIII $$VW55501114M4445557$A $A$A$ACWXXX+ ; ;ID#!--dK@@K  c4 @ @ @--c22E   99999 : : : : 1 1A   /!/// 0 0 0 0.)))#rLct|jD]H}|jtkr6|d||jddddSIdS)z8Generate call to function representing module top level.zchar result = z();zif (result == 2)r}N)reversedrrfr(r6rr)rIr\rrs rJrz&GroupGenerator.generate_top_level_calls6+,,  Bw.((""OW%A%A"'%J%JOOO&$  )  rLlist[HeaderDeclaration]cgi|jjD]\}}t|d|<dfd D] }|S)a~Topologically sort the declaration dict by dependencies. Declarations can require other declarations to come prior in C (such as declaring structs). In order to guarantee that the C output will compile the declarations will thus need to be properly ordered. This simple DFS guarantees that we have a proper ordering. This runs in O(V + E). FrfrrFrGc|}|jrdS|jjD] }||jd|_dS)NT)rDrC dependenciesr/)rfrchild_toposort_visitmarked_declarationsrs rJrz=GroupGenerator.toposort_declarations.._toposort_visitsd&t,Dy )6 ' '&&&& MM$* + + +DIIIrL)rfrrFrG)rrrwrB)rIrvrfrrrs @@@rJr7z$GroupGenerator.toposort_declarationss<>L-3355 A ADAq%6q%%@%@  " "        ( " "D OD ! ! ! ! rLNrK type_spacedrfrLcd|vr||}n"|dd\}}||d|}|sd}n |d|dg}||jjvr#t|d||jj|<dSdS)N[rrtr)r:)r rrr)rIrrfrLbaseabr:s rJrSzGroupGenerator.declare_globals k ! !!)4))DD$$S!,,DAq#####D 0DD.. .../D t|0 0 0.?4 QU.V.V.VDL %d + + + 1 0rLc^|d|}|d|dS)Nr~ PyObject *rrS)rIr?rrs rJr)z'GroupGenerator.declare_internal_globals s3)))[AA  L+66666rLcB||dzdtS)N _internalrz)rr%)rIr?rs rJrz*GroupGenerator.module_internal_static_names""";#> &&s++I[IIYIIIIrL identifierc^||d}|d|dS)Nrr)rIrrrus rJdeclare_static_pyobjectz&GroupGenerator.declare_static_pyobject2s3$$Z66 L&11111rLr4 list[str]c|D]G}|||t}td|dd|dgd|jj|<HdS)Nrrrz = NULL;Fr)rr)rrr)rIr\r4rrfrs rJr3z GroupGenerator.declare_type_vars6sx"  D!--dF?-SSK8I+[+++3k3334"999GO ( 5 5  rL)rgrrrrrrbrrr7rUr9rFrG)rFr)rFr)rFrG)rdrrerrFrG)rrrFrG)rrr?rr\r.rFrG)r\r.rrrFrG)rFr)rrrfrrLrrFrG)r?rrrrFrG)r?rrrrFr)rrrrrFrG)r\rr2rrrrFrG) r\rrfrrr3rrrFr)rrrrrFrG)r\rr4rrrrFrG)rMrNrOrKpropertyrrrr'r;r<r8r-rr7rSr)rr(r*r1rrr3rQrLrJrrs"6"6"6"6HOOOXO^^^X^E E E E N\\\\@:%:%:%:%x]b]b]b]b~DDDD*jjjjX    >IMWWWWWW 7777ZZZZ ; ; ; ;....    JJJJ 2222rLrTdepsdict[T, set[T]]list[T]c`gtdfd D] }|S)zUTopologically sort a dict from item to dependencies. This runs in O(V + E). itemrrFrGc|vrdS|D] }|||dSrZ)r/add)rrrrvisitvisiteds rJrztoposort..visitKs] 7?? F$Z  E E%LLLL d DrL)rrrFrG)set)rrrrrs` @@@rJtoposortrCsh FeeG d MrLrtuple[int, int]rEcD|j|jdkrdS|jdkSdS)N__call__TrK)rrf)rrs rJrr[s. } 7j 4w*$$ 4rLr$r$c|jD];}|jD]1}t|tr||j2???? MM# 776??rL)NN)rerrTrrUr9rVrWrrrrrFr) rrrrrr5rUr9rr,rFr/) rrrr5rUr9rr,rFr/) rVrWrgr/rrrr5rUr9rFr)rhrrprrTrrFr)rr rFr) rgr/rrrbrrrrFrG) rrrrrr5rjr1rFr/) rrrUr9rr,rVrWrFr)rr-rrrFrG)rrrfrrFr)rrrFr)rrrFr)rr-rrrFrE)rr-r$r$rFrG)rrrFr)}rP __future__rrurycollections.abcrtypingrr mypy.buildrrr r r r r r mypy.errorsr mypy.fscacher mypy.nodesr mypy.optionsr mypy.pluginrr mypy.utilrrmypyc.codegen.cstringrmypyc.codegen.emitrrrrmypyc.codegen.emitclassrrmypyc.codegen.emitfuncrrmypyc.codegen.emitwrapperr r!r"r#mypyc.codegen.literalsr$ mypyc.commonr%r&r'r(r)r*r+ mypyc.errorsr,mypyc.ir.func_irr-mypyc.ir.module_irr.r/r0 mypyc.ir.opsr1r2mypyc.ir.rtypesr3mypyc.irbuild.mainr4mypyc.irbuild.mapperr5mypyc.irbuild.preparer6 mypyc.namegenr7r8 mypyc.optionsr9 mypyc.transform.copy_propagationr:mypyc.transform.exceptionsr; mypyc.transform.flag_eliminationr<mypyc.transform.lowerr=mypyc.transform.refcountr>mypyc.transform.spillr?mypyc.transform.uninitr@tuplelistrGrouprW FileContentsrBrSrrrrrrrrrrrr rrrrrr#rUrQrLrJrsNN #""""" $$$$$$$$$$$$$$                    %$$$$$(((((( 33333333--------666666^^^^^^^^^^^^LLLLLLLLSSSSSSSS ,+++++ ######GGGGGGGGGG////////!!!!!!''''''''''''//////66666666))))))@@@@@@@@@@@@@@@@@@******======//////777777, d;#./ eE#s(O$ LYLYLYLYLY&LYLYLYh'+# *6666r<%%%%P7777 CCCC2&2&2&2&j$%@%@%@%@P    ....3333 ] ] ] ] ] ] ] ] @ GCLL0 2 2 2 2rL