HEX

File: //usr/local/lib/python3.10/dist-packages/numpy/distutils/__pycache__/ccompiler_opt.cpython-310.pyc
o

���g&��	@s�dZddlZddlZddlZddlZddlZddlZddlZGdd�d�ZGdd�d�Z	iZ
Gdd�d�ZGd	d
�d
�ZGdd�d�Z
Gd
d�d�ZGdd�dee	eee
e�Zdd�ZdS)aProvides the `CCompilerOpt` class, used for handling the CPU/hardware
optimization, starting from parsing the command arguments, to managing the
relation between the CPU baseline and dispatch-able features,
also generating the required C headers and ending with compiling
the sources with proper compiler's flags.

`CCompilerOpt` doesn't provide runtime detection for the CPU features,
instead only focuses on the compiler side, but it creates abstract C headers
that can be used later for the final runtime dispatching process.�Nc@seZdZdZdZdZdZdZej	�
ej	�ej	�e
��d�ZiZdZdZeeddd	d
�edddd
�eddd	d
�ed
ddd
�edddd
�edddd
�d�Zedddddddd�Zed}idedddd��deddd d!��d"ed#dd$d!��d%ed&d"d'd!��d(ed)d%d*d!��d+ed,d(d-d!��d.ed/d+d0��d1ed2d.d3dd4��d5ed6d1d7d!��d8ed9d1d7d!��d:ed;d1d0��d<ed=d:d0��d>ed?d:d0��d@edAdBddCdD��dEedFd@d0��dGedHdEdIdGddJ��dKedLdGdMdKddJ��dNedOdEdPdNddQdR��dSedTdNdUdSdV��dWedXdNdYdWddJ��dZed[d\d]dZddJ��d^ed_dZd`d^ddJ��daeddbdcdd��deeddaddf��dged#deddhdD��died&dgddjdD��dkeddldm��dneddkddf��doed#dnddf��dpeddqdm��dreddpd0��dsed#drd0��dted&duddf��dved)dtd0��dwed,dtd0��dxed/dvd0���Zdydz�Zd{d|�ZdS)~�_Configa�An abstract class holds all configurable attributes of `CCompilerOpt`,
    these class attributes can be used to change the default behavior
    of `CCompilerOpt` in order to fit other requirements.

    Attributes
    ----------
    conf_nocache : bool
        Set True to disable memory and file cache.
        Default is False.

    conf_noopt : bool
        Set True to forces the optimization to be disabled,
        in this case `CCompilerOpt` tends to generate all
        expected headers in order to 'not' break the build.
        Default is False.

    conf_cache_factors : list
        Add extra factors to the primary caching factors. The caching factors
        are utilized to determine if there are changes had happened that
        requires to discard the cache and re-updating it. The primary factors
        are the arguments of `CCompilerOpt` and `CCompiler`'s properties(type, flags, etc).
        Default is list of two items, containing the time of last modification
        of `ccompiler_opt` and value of attribute "conf_noopt"

    conf_tmp_path : str,
        The path of temporary directory. Default is auto-created
        temporary directory via ``tempfile.mkdtemp()``.

    conf_check_path : str
        The path of testing files. Each added CPU feature must have a
        **C** source file contains at least one intrinsic or instruction that
        related to this feature, so it can be tested against the compiler.
        Default is ``./distutils/checks``.

    conf_target_groups : dict
        Extra tokens that can be reached from dispatch-able sources through
        the special mark ``@targets``. Default is an empty dictionary.

        **Notes**:
            - case-insensitive for tokens and group names
            - sign '#' must stick in the begin of group name and only within ``@targets``

        **Example**:
            .. code-block:: console

                $ "@targets #avx_group other_tokens" > group_inside.c

            >>> CCompilerOpt.conf_target_groups["avx_group"] = \
            "$werror $maxopt avx2 avx512f avx512_skx"
            >>> cco = CCompilerOpt(cc_instance)
            >>> cco.try_dispatch(["group_inside.c"])

    conf_c_prefix : str
        The prefix of public C definitions. Default is ``"NPY_"``.

    conf_c_prefix_ : str
        The prefix of internal C definitions. Default is ``"NPY__"``.

    conf_cc_flags : dict
        Nested dictionaries defining several compiler flags
        that linked to some major functions, the main key
        represent the compiler name and sub-keys represent
        flags names. Default is already covers all supported
        **C** compilers.

        Sub-keys explained as follows:

        "native": str or None
            used by argument option `native`, to detect the current
            machine support via the compiler.
        "werror": str or None
            utilized to treat warning as errors during testing CPU features
            against the compiler and also for target's policy `$werror`
            via dispatch-able sources.
        "maxopt": str or None
            utilized for target's policy '$maxopt' and the value should
            contains the maximum acceptable optimization by the compiler.
            e.g. in gcc `'-O3'`

        **Notes**:
            * case-sensitive for compiler names and flags
            * use space to separate multiple flags
            * any flag will tested against the compiler and it will skipped
              if it's not applicable.

    conf_min_features : dict
        A dictionary defines the used CPU features for
        argument option `'min'`, the key represent the CPU architecture
        name e.g. `'x86'`. Default values provide the best effort
        on wide range of users platforms.

        **Note**: case-sensitive for architecture names.

    conf_features : dict
        Nested dictionaries used for identifying the CPU features.
        the primary key is represented as a feature name or group name
        that gathers several features. Default values covers all
        supported features but without the major options like "flags",
        these undefined options handle it by method `conf_features_partial()`.
        Default value is covers almost all CPU features for *X86*, *IBM/Power64*
        and *ARM 7/8*.

        Sub-keys explained as follows:

        "implies" : str or list, optional,
            List of CPU feature names to be implied by it,
            the feature name must be defined within `conf_features`.
            Default is None.

        "flags": str or list, optional
            List of compiler flags. Default is None.

        "detect": str or list, optional
            List of CPU feature names that required to be detected
            in runtime. By default, its the feature name or features
            in "group" if its specified.

        "implies_detect": bool, optional
            If True, all "detect" of implied features will be combined.
            Default is True. see `feature_detect()`.

        "group": str or list, optional
            Same as "implies" but doesn't require the feature name to be
            defined within `conf_features`.

        "interest": int, required
            a key for sorting CPU features

        "headers": str or list, optional
            intrinsics C header file

        "disable": str, optional
            force disable feature, the string value should contains the
            reason of disabling.

        "autovec": bool or None, optional
            True or False to declare that CPU feature can be auto-vectorized
            by the compiler.
            By default(None), treated as True if the feature contains at
            least one applicable flag. see `feature_can_autovec()`

        "extra_checks": str or list, optional
            Extra test case names for the CPU feature that need to be tested
            against the compiler.

            Each test case must have a C file named ``extra_xxxx.c``, where
            ``xxxx`` is the case name in lower case, under 'conf_check_path'.
            It should contain at least one intrinsic or function related to the test case.

            If the compiler able to successfully compile the C file then `CCompilerOpt`
            will add a C ``#define`` for it into the main dispatch header, e.g.
            ``#define {conf_c_prefix}_XXXX`` where ``XXXX`` is the case name in upper case.

        **NOTES**:
            * space can be used as separator with options that supports "str or list"
            * case-sensitive for all values and feature name must be in upper-case.
            * if flags aren't applicable, its will skipped rather than disable the
              CPU feature
            * the CPU feature will disabled if the compiler fail to compile
              the test file
    FN�checks�NPY_�NPY__z
-march=nativez-O3z-Werror)�native�opt�werrorz-Werror=switch -Werrorz-xHostz/QxHostz/O3z/Werrorz/O2z/WXz-mcpu=a64fx)�gcc�clang�icc�iccw�msvc�fcczSSE SSE2z
SSE SSE2 SSE3�zVSX VSX2zNEON NEON_FP16 NEON_VFPV4 ASIMD)�x86�x64�ppc64�ppc64le�s390x�armhf�aarch64�SSE�zxmmintrin.h�SSE2)�interest�headers�implies�zemmintrin.h)rrr�SSE3�zpmmintrin.h�SSSE3�ztmmintrin.h�SSE41�zsmmintrin.h�POPCNT�zpopcntintrin.h�SSE42�)rr�AVX�zimmintrin.h)rrr�implies_detect�XOP�	zx86intrin.h�FMA4�
�F16C��FMA3��AVX2�
�AVX512F�z	FMA3 AVX2�AVX512F_REDUCE)rrr*�extra_checks�AVX512CD��
AVX512_KNL�(zAVX512ER AVX512PF)rr�group�detectr*�
AVX512_KNM�)z)AVX5124FMAPS AVX5124VNNIW AVX512VPOPCNTDQ�
AVX512_SKX�*zAVX512VL AVX512BW AVX512DQzAVX512BW_MASK AVX512DQ_MASK)rrr=r>r*r8�
AVX512_CLX�+�
AVX512VNNI)rrr=r>�
AVX512_CNL�,zAVX512IFMA AVX512VBMI�
AVX512_ICL�-zAVX512_CLX AVX512_CNLz(AVX512VBMI2 AVX512BITALG AVX512VPOPCNTDQ�
AVX512_SPR�.�
AVX512FP16�VSXz	altivec.h�VSX_ASM)rrr8�VSX2)rrr*�VSX3�VSX3_HALF_DOUBLE�VSX4�VSX4_MMA�VXzvecintrin.h)rr�VXE�VXE2�NEONz
arm_neon.h�	NEON_FP16�
NEON_VFPV4�ASIMDzNEON_FP16 NEON_VFPV4�ASIMDHP�ASIMDDP�ASIMDFHMc
Cs�|jriS|jp
|j}|jp|jp|j}|r�|r�tdxidtdd��dtdd��dtdd��dtd	d��d
tdd��dtd
d��dtdd��dtdd��dtdd��dtdd��dtdd��dtdd��dtdd��dtdd��dtdd��d td!d��d"td#d��d$td%d��d&td'd��d(td)d��d*td+d��d,td-d���S|�r/|j�r/tdxidtdd��dtdd��dtdd��dtd	d��d
tdd��di�dtdd��dtdd��di�dtd.d/��dtd.d/��dtd0d1d2��dtdd1d2��dtd3d4d2��dtd5d4d2��d td6d��d"td7d��d$td8d��d&td9d��d(td:d��d*td;d��d,td<d/���S|�r�|j�r�tdxidtd=d��dtd>d��dtd?d��dtd@d��d
tdAd��di�dtdBd��dtdCd��di�dtd.d/��dtd.d/��dtd0dDd2��dtddDd2��dtd3dEd2��dtd5dEd2��d tdFd��d"tdGd��d$tdHd��d&tdId��d(tdJd��d*tdKd��d,td<d/���S|�r�|j	�r�tdxid|j�r�td=d�ni�d|j�r�td>d�nhi�di�di�d
i�dtdLdM��di�dtdCd��di�dtdNdM��dtdNdM��dtd0dOd2��dtdPdOd2��dtdQdRd2��dtdSdRd2��d tdTd/��d"tdTd/��d$tdRd��d&i�d(i�d*i�d,tdTd/���S�di�di�d
i�dtdLdM��di�dtdCd��di�dtdNdM��dtdNdM��dtd0dOd2��dtdPdOd2��dtdQdRd2��dtdSdRd2��d tdTd/��d"tdTd/��d$tdRd��d&i�d(i�d*i�d,tdTd/���S|j
�p�|j}|�r�tt|j
�r�dUndVdWd2�tdXdYdZ�td[dYdZ�td\dYdZ�d]�}|j�r�d^|d_d`<dX|dUd`<da|dbd`<dc|ddd`<|S|j}|�rttded�tdfdYdZ�tdgdYdZ�dh�}|S|j
�r7|�r7ttdidjdk�tdldjdk�tdmdjdk�tdndjdk�tdod�tdpd�tdqd�dr�S|j�r^|�r^ttdsd�tdtd�tdud�tdvd�tdod�tdpd�tdqd�dr�SiS)ya7Return a dictionary of supported CPU features by the platform,
        and accumulate the rest of undefined options in `conf_features`,
        the returned dict has same rules and notes in
        class attribute `conf_features`, also its override
        any options that been set in 'conf_features'.
        rz-msse)�flagsrz-msse2rz-msse3r z-mssse3r"z-msse4.1r$z-mpopcntr&z-msse4.2r(z-mavxr/z-mf16cr+z-mxopr-z-mfma4r1z-mfmar3z-mavx2r5z-mavx512f -mno-mmxr9z
-mavx512cdr;z-mavx512er -mavx512pfr?z/-mavx5124fmaps -mavx5124vnniw -mavx512vpopcntdqrAz -mavx512vl -mavx512bw -mavx512dqrCz-mavx512vnnirFz-mavx512ifma -mavx512vbmirHz.-mavx512vbmi2 -mavx512bitalg -mavx512vpopcntdqrJz-mavx512fp16z!Intel Compiler doesn't support it)�disablez	F16C AVX2z-march=core-avx2)rr^z
AVX2 AVX512CDz-march=common-avx512zAVX2 AVX512Fz-xKNLz-xKNMz-xSKYLAKE-AVX512z
-xCASCADELAKEz-xCANNONLAKEz-xICELAKE-CLIENTzNot supported yetz	/arch:SSEz
/arch:SSE2z
/arch:SSE3z/arch:SSSE3z/arch:SSE4.1z/arch:SSE4.2z	/arch:AVXz/arch:CORE-AVX2z/Qx:COMMON-AVX512z/Qx:KNLz/Qx:KNMz/Qx:SKYLAKE-AVX512z/Qx:CASCADELAKEz/Qx:CANNONLAKEz/Qx:ICELAKE-CLIENTznmmintrin.h)rzammintrin.hz
/arch:AVX2z	F16C FMA3zAVX2 AVX512CD AVX512_SKXz/arch:AVX512zAVX512F AVX512_SKXz MSVC compiler doesn't support itrOrz-mvsxz-mcpu=power8F)r^r*z-mcpu=power9 -mtune=power9z-mcpu=power10 -mtune=power10)rMrOrPrRz-maltivec -mvsxrMr^z-mcpu=power9rPz
-mcpu=power10rRz-march=arch11 -mzvectorz
-march=arch12z
-march=arch13)rTrUrVzNEON_FP16 NEON_VFPV4 ASIMDT)r�autoveczNEON NEON_VFPV4 ASIMDzNEON NEON_FP16 ASIMDzNEON NEON_FP16 NEON_VFPV4z-march=armv8.2-a+fp16z-march=armv8.2-a+dotprodz-march=armv8.2-a+fp16fml)rWrXrYrZr[r\r]z
-mfpu=neonz"-mfpu=neon-fp16 -mfp16-format=ieeez-mfpu=neon-vfpv4z'-mfpu=neon-fp-armv8 -march=armv8-a+simdN�)�cc_noopt�	cc_on_x86�	cc_on_x64�	cc_is_gcc�cc_is_clang�	cc_is_fcc�dict�	cc_is_icc�
cc_is_iccw�
cc_is_msvc�
cc_on_ppc64le�cc_on_ppc64�cc_on_s390x�
cc_on_aarch64�cc_on_armhf)�self�on_x86�is_unix�on_power�partial�on_zarchrara�H/usr/local/lib/python3.10/dist-packages/numpy/distutils/ccompiler_opt.py�conf_features_partialJs�
�
�
�
�
�
�
�
�
	�

�
�
�

�
�
�
���
�
�
���
�
�
�
�
�
��
�
�	�

�
�
�������
�
�
�
�
�
�
� 
�
�
�
�
��
�
�	�

�
�
��������
�
�
�
�
�
�
 �"������
��
�	�

�
�
������������
!�"�#�$�%������
��
�	�

�
�
������������
!�"�#�$�%��*�������������������������z_Config.conf_features_partialcsf|jdur ddl�ddl}|�����fdd�}t�|��|_|jdur1tj�	t
�|jg|_dSdS)Nrcs&z����WdStyYdSw�N)�rmtree�OSErrorra��shutil�tmprarw�rm_temp@s
�z!_Config.__init__.<locals>.rm_temp)�
conf_tmp_pathr}�tempfile�mkdtemp�atexit�register�conf_cache_factors�os�path�getmtime�__file__�conf_nocache)rqr�rrar|rw�__init__;s




��z_Config.__init__ra)�__name__�
__module__�__qualname__�__doc__r��
conf_nooptr�r�r�r��join�dirname�realpathr��conf_check_path�conf_target_groups�
conf_c_prefix�conf_c_prefix_rh�
conf_cc_flags�conf_min_features�
conf_featuresrxr�rarararwrsN"���
�����'�	���	�
���
������������� ��%��*��.��2��7��=�?�A��D��H�J�L�N�O�Q�S�U�W�Y�[rrc@s�eZdZdZdd�Zddd�Zgfdd�Zd	d
�Zedd��Z	ed
d��Z
edd�dd��Zedd��Zedd��Z
ddd�Ze�d�Zeddd��ZdS)�
_Distutilsa�A helper class that provides a collection of fundamental methods
    implemented in a top of Python and NumPy Distutils.

    The idea behind this class is to gather all methods that it may
    need to override in case of reuse 'CCompilerOpt' in environment
    different than of what NumPy has.

    Parameters
    ----------
    ccompiler : `CCompiler`
        The generate instance that returned from `distutils.ccompiler.new_compiler()`.
    cCs
||_dSry)�
_ccompiler)rq�	ccompilerrararwr�[s
z_Distutils.__init__NcKsLt|t�sJ�t|t�sJ�|�dg�|}|s|j}|j|fd|i|��S)zWrap CCompiler.compile()�extra_postargs)�
isinstance�list�popr��compile)rq�sourcesr^r��kwargsrararw�dist_compile^sz_Distutils.dist_compilec

Cs�t|t�sJ�ddlm}|j}t|dd�}|r2t|jdd�}|dvr+t|d|j�nt|d|j�d}z|j	|g|||j
d	�d
}Wn|y^}	z|jt|	�d
d�WYd}	~	nd}	~	ww|rgt|d|�|S)zgReturn True if 'CCompiler.compile()' able to compile
        a source file with certain flags.
        r��CompileError�spawnN�
compiler_typer)r
F)�macros�
output_dirT��stderr)r��str�distutils.errorsr�r��getattr�setattr�_dist_test_spawn_paths�_dist_test_spawnr�r��dist_log)
rq�sourcer^r�r��cc�bk_spawn�cc_type�test�erararw�	dist_tesths,���z_Distutils.dist_testcCs�t|d�r|jSt|jdd�}|dvrd}n|dvrd}n	dd	lm}|�}t|jd
t|jdd��}|r8|dkrGt|d
�rB|d}nt|�}n|}t|d
�r^t|�dkr^d�|dd��}nt	j
�dd�}|t	j
�dd�7}|||f|_|jS)a!
        Return a tuple containing info about (platform, compiler, extra_args),
        required by the abstract class '_CCompiler' for discovering the
        platform environment. This is also used as a cache factor in order
        to detect any changes happening from outside.
        �
_dist_infor�r)�intelem�intelemw�x86_64)�intel�intelw�intelerr)�get_platform�compiler�compiler_so�unix�__iter__r� N�CFLAGS�CPPFLAGS)�hasattrr�r�r��distutils.utilr�r��lenr�r��environ�get)rqr��platformr��cc_infor��
extra_argsrararw�	dist_info�s*



z_Distutils.dist_infocG�ddlm}|tj|���)zRaise a compiler errorrr�)r�r�r��	_dist_str)�argsr�rararw�
dist_error��z_Distutils.dist_errorcGr�)zRaise a distutils errorr)�DistutilsError)r�r�r�r�)r�r�rararw�
dist_fatal�r�z_Distutils.dist_fatalFr�cGs6ddlm}tj|�}|r|�|�dS|�|�dS)zPrint a console messager)�logN)�numpy.distutilsr�r�r��warn�info)r�r�r��outrararwr��s

z_Distutils.dist_logc
CsNddlm}z|||�WSty&}ztj|dd�WYd}~dSd}~ww)zALoad a module from file, required by the abstract class '_Cache'.r)�exec_mod_from_locationTr�N)�	misc_utilr��	Exceptionr�r�)�namer�r�r�rararw�dist_load_module�s��z_Distutils.dist_load_modulecsN�fdd��t��d}d|j|jf}d��fdd�g|�RD��}||S)z+Return a string to print by log and errors.csJt|t�s!t|d�r!g}|D]	}|��|��qdd�|�dSt|�S)Nr��(r��))r�r�r��appendr�)�arg�ret�a��to_strrarwr��sz$_Distutils._dist_str.<locals>.to_strrzCCompilerOpt.%s[%d] : r�csg|]}�|��qSrara)�.0r�r�rarw�
<listcomp>�s��z(_Distutils._dist_str.<locals>.<listcomp>)�inspect�stack�function�linenor�)r�r��startr�rar�rwr��s�z_Distutils._dist_strc	CsZt|jd�s
|�|�dSt�d�}z|jjtjd<|�|�W|tjd<dS|tjd<w)z�
        Fix msvc SDK ENV path same as distutils do
        without it we get c1: fatal error C1356: unable to find mspdbcore.dll
        �_pathsNr�)r�r�r�r��getenvr�r�)rq�cmd�display�old_pathrararwr��s

z!_Distutils._dist_test_spawn_pathsz/.*(warning D9002|invalid argument for option).*c
Cs�z$tj|tjdd�}|rt�tj|�r"t�d|d|�WdSWdSWdStjy=}z|j	}|j
}WYd}~nd}~wtyR}z
|}d}WYd}~nd}~wwt�d|d||f�dS)NT)r��textzFlags in commandz/aren't supported by the compiler, output -> 
%s��Commandz(failed with exit status %d output -> 
%s)�
subprocess�check_output�STDOUT�re�matchr��_dist_warn_regexr��CalledProcessError�output�
returncoder{)r�r��o�exc�sr�rararwr��s:
�����������z_Distutils._dist_test_spawnry)r�r�r�r�r�r�r�r��staticmethodr�r�r�r�r�r�r�r�rr�rarararwr�Ns,

%

	
	

�r�c@sHeZdZdZe�d�Zddd�Zdd�Zdd	�Z	d
d�Z
edd
��ZdS)�_Cachea'An abstract class handles caching functionality, provides two
    levels of caching, in-memory by share instances attributes among
    each other and by store attributes into files.

    **Note**:
        any attributes that start with ``_`` or ``conf_`` will be ignored.

    Parameters
    ----------
    cache_path : str or None
        The path of cache file, if None then cache in file will disabled.

    *factors :
        The caching factors that need to utilize next to `conf_cache_factors`.

    Attributes
    ----------
    cache_private : set
        Hold the attributes that need be skipped from "in-memory cache".

    cache_infile : bool
        Utilized during initializing this class, to determine if the cache was able
        to loaded from the specified cache path in 'cache_path'.
    z
^(_|conf_)NcGshi|_t�|_d|_d|_|jr|�d�dS|jg|�|j�R�|_	||_|rzt
j�|�rz|�d|�|�
d|�}|sD|jddd�n6t|d�rNt|d	�sV|jd
dd�n$|j	|jkru|�d�|j��D]
\}}t|||�qfd|_n|�d�|js�t�|j	�}|r�|�d
�|j��D]\}}||jvs�t�|j|�r�q�t|||�q�|t|j	<t�|j�dS)NFzcache is disabled by `Config`zload cache from file ->�cachez)unable to load the cache file as a moduleTr��hash�datazinvalid cache filezhit the file cachezmiss the file cachezhit the memory cache)�cache_me�set�
cache_private�cache_infile�_cache_pathr�r��
cache_hashr��_cache_hashr�r��existsr�r�rr�itemsr��_share_cacher��__dict__r�r�
_cache_ignorer�r��cache_flush)rq�
cache_path�factors�	cache_mod�attr�val�other_cacherararwr�&sP
�
�



�
z_Cache.__init__cCs.t��D]\}}||krt�|�dSqdSry)rrr�)rq�hrrararw�__del__Ss
��z_Cache.__del__cCs�|jsdS|�d|j�|j��}|j��D]}t�|j|�r$|�|�qt	j
�|j�}t	j
�|�s7t	�
|�tj|dd�}t|jd��}|�t�d��|j��|�|�Wd�dS1sawYdS)z)
        Force update the cache.
        Nzwrite cache to path ->T)�compact�wz�            # AUTOGENERATED DON'T EDIT
            # Please make changes to the code generator             (distutils/ccompiler_opt.py)
            hash = {}
            data = \
            )rr�r�copy�keysr�rrr�r�r�r�r�makedirs�pprint�pformat�open�write�textwrap�dedent�formatr)rq�cdictr�d�	repr_dict�frararwrYs$

�
�"�z_Cache.cache_flushcGsDd}|D]}t|�D]}t|�|d>|d>|}|dM}q
q|S)Nrr%�l��)r��ord)rqr�chashr1�charrararwrus
�z_Cache.cache_hashcs�fdd�}|S)zr
        A static method that can be treated as a decorator to
        dynamically cache certain methods.
        csZt�jg|�|���|���R�}||jvr|j|S�|g|�Ri|��}||j|<|Sry)r�r�r%�valuesr
)rqr�r��	cache_key�ccb��cbrarw�
cache_wrap_me�s����


z _Cache.me.<locals>.cache_wrap_mera)r:r;rar9rw�mes
z	_Cache.mery)
r�r�r�r�r�r�rr�r!rrrr<rarararwr		s

-
r	c@s�eZdZdZdd�Zejdd��Zejgfdd��Zdd	�Z	e
�d
�Ze
�d�Z
e
�d�Ze
�d
�Zdd�Ze
�d�Ze
�d�Zdd�ZdS)�
_CCompilera2A helper class for `CCompilerOpt` containing all utilities that
    related to the fundamental compiler's functions.

    Attributes
    ----------
    cc_on_x86 : bool
        True when the target architecture is 32-bit x86
    cc_on_x64 : bool
        True when the target architecture is 64-bit x86
    cc_on_ppc64 : bool
        True when the target architecture is 64-bit big-endian powerpc
    cc_on_ppc64le : bool
        True when the target architecture is 64-bit litle-endian powerpc
    cc_on_s390x : bool
        True when the target architecture is IBM/ZARCH on linux
    cc_on_armhf : bool
        True when the target architecture is 32-bit ARMv7+
    cc_on_aarch64 : bool
        True when the target architecture is 64-bit Armv8-a+
    cc_on_noarch : bool
        True when the target architecture is unknown or not supported
    cc_is_gcc : bool
        True if the compiler is GNU or
        if the compiler is unknown
    cc_is_clang : bool
        True if the compiler is Clang
    cc_is_icc : bool
        True if the compiler is Intel compiler (unix like)
    cc_is_iccw : bool
        True if the compiler is Intel compiler (msvc like)
    cc_is_nocc : bool
        True if the compiler isn't supported directly,
        Note: that cause a fail-back to gcc
    cc_has_debug : bool
        True if the compiler has debug flags
    cc_has_native : bool
        True if the compiler has native flags
    cc_noopt : bool
        True if the compiler has definition 'DISABLE_OPT*',
        or 'cc_on_noarch' is True
    cc_march : str
        The target architecture name, or "unknown" if
        the architecture isn't supported
    cc_name : str
        The compiler name, or "unknown" if the compiler isn't supported
    cc_flags : dict
        Dictionary containing the initialized flags of `_Config.conf_cc_flags`
    cCs>t|d�rdSd}d}d}|��}|\}}}|||fD]}|D]\}	}
}t||	d�qq||f||ffD]%\}}
|D]\}	}
}|
rJt�|
|
tj�sJq:|rR|�|�sRq:t||	d�q4|D]\}	}
}|
rlt�|
|tj�slq\|rt|�|�stq\t||	d�q\|jr�|jd|�d�dd	�d|_	|j
r�|jd
dd	�d|_	|jr�	|jd|�d�dd	�d|_d|_
d
D]}t|d|�r�||_
nq�d|_dD]}t|d|�r�||_nq�i|_|j�|j�}|dur�|�d|j�|��D],\}}g|j|<}|�rt|t��sJ�|��}|D]}|�|g��r|�|��q	q�d|_dS)N�cc_is_cached))rdz.*(x|x86_|amd)64.*r)rcz.*(win32|x86|i386|i686).*r)rlz&.*(powerpc|ppc)64(el|le).*|.*powerpc.*z4defined(__powerpc64__) && defined(__LITTLE_ENDIAN__))rmz.*(powerpc|ppc).*|.*powerpc.*z1defined(__powerpc64__) && defined(__BIG_ENDIAN__))roz.*(aarch64|arm64).*r)rpz.*arm.*z3defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__))rnz	.*s390x.*r)�cc_on_noarchrr))rez.*(gcc|gnu\-g).*r)rfz	.*clang.*r)rjz.*(intelw|intelemw|iccw).*r)riz.*(intel|icc).*r)rkz.*msvc.*r)rgz.*fcc.*r)�
cc_is_noccrr))�cc_has_debugz$.*(O0|Od|ggdb|coverage|debug:full).*r)�
cc_has_nativez..*(-march=native|-xHost|/QxHost|-mcpu=a64fx).*r)rbz.*DISABLE_OPT.*rFTz]unable to detect CPU architecture which lead to disable the optimization. check dist_info:<<
z
>>r�z&Optimization is disabled by the Configz�unable to detect compiler type which leads to treating it as GCC. this is a normal behavior if you're using gcc-like compiler such as MinGW or IBM/XLC.check dist_info:<<
�unknown)rrrrrrr�cc_on_)r	r
rrr
r�cc_is_z=undefined flag for compiler '%s', leave an empty dict instead)r�r�r�r�r�
IGNORECASE�
cc_test_cexprr?r�rbr�r@re�cc_marchr��cc_name�cc_flagsr�r�r�rr�r��split�
cc_test_flagsr�r>)rq�detect_arch�detect_compiler�detect_argsr�r��
compiler_infor��sectionr�rgex�cexprr>�searchin�archr��compiler_flagsr^�nflagsr1rararwr��s�

����������
�
z_CCompiler.__init__cCsLt|t�sJ�|�d|�tj�|jd�}|�||�}|s$|jddd�|S)z@
        Returns True if the compiler supports 'flags'.
        z
testing flagsztest_flags.c�testing failedTr�)r�r�r�r�r�r�r�r�)rqr^�	test_pathr�rararwrL8sz_CCompiler.cc_test_flagscCs�|�d|�tj�|jd�}t|d��}|�t�d|�d���Wd�n1s*wY|�	||�}|s>|jddd	�|S)
zJ
        Same as the above but supports compile-time expressions.
        ztesting compiler expressionznpy_dist_test_cexpr.cr#z               #if !(zq)
                   #error "unsupported expression"
               #endif
               int dummy;
            NrXTr�)
r�r�r�r�r�r)r*r+r,r�)rqrSr^rY�fdr�rararwrGEs
��z_CCompiler.cc_test_cexprcCsDt|t�sJ�|js|js|jr|�|�S|js|jr |�|�S|S)a�
        Remove the conflicts that caused due gathering implied features flags.

        Parameters
        ----------
        'flags' list, compiler flags
            flags should be sorted from the lowest to the highest interest.

        Returns
        -------
        list, filtered from any conflicts.

        Examples
        --------
        >>> self.cc_normalize_flags(['-march=armv8.2-a+fp16', '-march=armv8.2-a+dotprod'])
        ['armv8.2-a+fp16+dotprod']

        >>> self.cc_normalize_flags(
            ['-msse', '-msse2', '-msse3', '-mssse3', '-msse4.1', '-msse4.2', '-mavx', '-march=core-avx2']
        )
        ['-march=core-avx2']
        )	r�r�rerfri�_cc_normalize_unixrkrj�_cc_normalize_win)rqr^rararw�cc_normalize_flagsXs

z_CCompiler.cc_normalize_flagsz^(-mcpu=|-march=|-x[A-Z0-9\-])zB^(?!(-mcpu=|-march=|-x[A-Z0-9\-]|-m[a-z0-9\-\.]*.$))|(?:-mzvector)z^(-mfpu|-mtune)z[0-9.]csB�fdd�}t|�dkr|Stt|��D]`\}}t��j|�s q|d|d�}||d�}tt�jj	|��}||�\}}	}
|dkrgt|
�dkrg|D]}||�\}}
}||kr]||
}
qL|	dd�
|
�}||g}|dkrt||7}g}t�}t|�D] }t��j|�}|s�n|d|vr�q~|�
|d�|�d|�q~|S)Nc	s@|�d�}tdd�t��j|d���}||d|dd�fS)N�+�0rrr)rK�floatr�r��findall�_cc_normalize_arch_ver)r1�tokens�ver�rqrarw�	ver_flags�s

�z0_CCompiler._cc_normalize_unix.<locals>.ver_flagsrrr^)r��	enumerate�reversedr�r�_cc_normalize_unix_mrgxr��filter�_cc_normalize_unix_frgx�searchr�r�_cc_normalize_unix_krgx�add�insert)rqr^rf�i�cur_flag�lower_flags�upper_flags�filteredrdrU�subflags�xflag�xver�_�	xsubflags�final_flags�matchedr1rrarerwr[�sD	��
z_CCompiler._cc_normalize_unixz^(?!(/arch\:|/Qx\:))z
^(/arch|/Qx:)cCs^tt|��D]&\}}t�|j|�sq|d7}tt|jj|d|���||d�S|S)Nr)	rgrhr�r�_cc_normalize_win_mrgxr�rj�_cc_normalize_win_frgxrl)rqr^rpr1rararwr\�s��z_CCompiler._cc_normalize_winN)r�r�r�r�r�r	r<rLrGr]r�r�rirkrmrbr[r}r|r\rarararwr=�s80v
����1��r=c@s�eZdZdZdd�Zddgfdd�Zdd�Zd%d
d�Zd%dd
�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
ejdd��Zejdgfdd��Zejdgfdd��Zejdd��Zejd d!��Zd&d#d$�ZdS)'�_Featurea�A helper class for `CCompilerOpt` that managing CPU features.

    Attributes
    ----------
    feature_supported : dict
        Dictionary containing all CPU features that supported
        by the platform, according to the specified values in attribute
        `_Config.conf_features` and `_Config.conf_features_partial()`

    feature_min : set
        The minimum support of CPU features, according to
        the specified values in attribute `_Config.conf_min_features`.
    c	st|d�rdS|��|_}t|���D]G}||�|j|}���fdd�|��D����d�}|durF|�	|�|j
d||dd�qdD]}��|�}t|t�rZ|�
��|<qHqt�|_|j�|jd	�}|���
�D]
}||jvr{|j�|�qnd|_dS)
N�feature_is_cachedcsi|]\}}|�vr||�qSrara)r��k�v��featurerarw�
<dictcomp>�sz%_Feature.__init__.<locals>.<dictcomp>r_zfeature '%s' is disabled,Tr�)rr=r>rr^r8r)r�rx�feature_supportedr�r%r��updaterr�r�r�r�r�rKr�feature_minr�rH�upperrnr)	rq�	pfeatures�feature_name�cfeature�disabled�option�oval�min_f�Frar�rwr��s<

�

�

��
�
z_Feature.__init__NcCsv|dust|t�st|d�sJ�|dust|t�sJ�|dur$|j��}t�}|D]}|j|||d�r8|�|�q)|S)a�
        Returns a set of CPU feature names that supported by platform and the **C** compiler.

        Parameters
        ----------
        names : sequence or None, optional
            Specify certain CPU features to test it against the **C** compiler.
            if None(default), it will test all current supported features.
            **Note**: feature names must be in upper-case.

        force_flags : list or None, optional
            If None(default), default compiler flags for every CPU feature will
            be used during the test.

        macros : list of tuples, optional
            A list of C macro definitions.
        Nr���force_flagsr�)	r�r�r�r�r�r%r�feature_is_supportedrn)rq�namesr�r��supported_namesr1rararw�
feature_names�s ��
�
�z_Feature.feature_namescCs|��sJ�||jvS)z�
        Returns True if a certain feature is exist and covered within
        ``_Config.conf_features``.

        Parameters
        ----------
        'name': str
            feature name in uppercase.
        )�isupperr�)rqr�rararw�feature_is_exists

z_Feature.feature_is_existFcs�fdd�}t|||d�S)az
        Sort a list of CPU features ordered by the lowest interest.

        Parameters
        ----------
        'names': sequence
            sequence of supported feature names in uppercase.
        'reverse': bool, optional
            If true, the sorted features is reversed. (highest interest)

        Returns
        -------
        list, sorted CPU features
        csBt|t�r�j|dSt�fdd�|D��}|t|�d7}|S)Nrcsg|]	}�j|d�qS)r)r��r�r1rerarwr�=sz<_Feature.feature_sorted.<locals>.sort_cb.<locals>.<listcomp>r)r�r�r��maxr�)r��rankrerarw�sort_cb9s

z(_Feature.feature_sorted.<locals>.sort_cb)�reverse�key)�sorted)rqr�r�r�rarerw�feature_sorted*s	z_Feature.feature_sortedcslt�f��fdd�	�t|t�r�|�}|g}nt|d�sJ�t�}|D]	}|��|��}q#|s4|�|�|S)a�
        Return a set of CPU features that implied by 'names'

        Parameters
        ----------
        names : str or sequence of str
            CPU feature name(s) in uppercase.

        keep_origins : bool
            if False(default) then the returned set will not contain any
            features from 'names'. This case happens only when two features
            imply each other.

        Examples
        --------
        >>> self.feature_implies("SSE3")
        {'SSE', 'SSE2'}
        >>> self.feature_implies("SSE2")
        {'SSE'}
        >>> self.feature_implies("SSE2", keep_origins=True)
        # 'SSE2' found here since 'SSE' and 'SSE2' imply each other
        {'SSE', 'SSE2'}
        csTt�}�j|}|�dg�D]}|�|�||vrq|�|�|��||��}q|S)Nr)rr�r�rn�union)r��_callerrr/rp��get_impliesrqrarwr�\s


z-_Feature.feature_implies.<locals>.get_impliesr�)rr�r�r�r��difference_update)rqr��keep_originsr�nrar�rw�feature_impliesDs


z_Feature.feature_impliescCs.t|t�rt|f�}nt|�}|�|�|��S)z/same as feature_implies() but combining 'names')r�r�rr�r�)rqr�rararw�feature_implies_cus
z_Feature.feature_implies_ccs^t|t�s
t|d�sJ�|j|dd���fdd�|D�}t|�dkr-|j|dd�dd	�}|S)
a
        Return list of features in 'names' after remove any
        implied features and keep the origins.

        Parameters
        ----------
        'names': sequence
            sequence of CPU feature names in uppercase.

        Returns
        -------
        list of CPU features sorted as-is 'names'

        Examples
        --------
        >>> self.feature_ahead(["SSE2", "SSE3", "SSE41"])
        ["SSE41"]
        # assume AVX2 and FMA3 implies each other and AVX2
        # is the highest interest
        >>> self.feature_ahead(["SSE2", "SSE3", "SSE41", "AVX2", "FMA3"])
        ["AVX2"]
        # assume AVX2 and FMA3 don't implies each other
        >>> self.feature_ahead(["SSE2", "SSE3", "SSE41", "AVX2", "FMA3"])
        ["AVX2", "FMA3"]
        r�T)r�c�g|]}|�vr|�qSrara)r�r��rrarwr���z*_Feature.feature_ahead.<locals>.<listcomp>r�r�Nr)r�r�r�r�r�r�)rqr��aheadrar�rw�
feature_ahead}s��z_Feature.feature_aheadcs�t|t�s
t|d�sJ�g}|D]5���������fdd�|D�}|r@��|�g�}�|dd�vr5q|�|dd�d�|���q|S)am
        same as 'feature_ahead()' but if both features implied each other
        and keep the highest interest.

        Parameters
        ----------
        'names': sequence
            sequence of CPU feature names in uppercase.

        Returns
        -------
        list of CPU features sorted as-is 'names'

        Examples
        --------
        >>> self.feature_untied(["SSE2", "SSE3", "SSE41"])
        ["SSE2", "SSE3", "SSE41"]
        # assume AVX2 and FMA3 implies each other
        >>> self.feature_untied(["SSE2", "SSE3", "SSE41", "FMA3", "AVX2"])
        ["SSE2", "SSE3", "SSE41", "AVX2"]
        r�cs&g|]}|�vr���|�vr|�qSra)r�)r��nn�rr�rqrarwr��s
�z+_Feature.feature_untied.<locals>.<listcomp>rNr)r�r�r�r�r��remover�)rqr��final�tiedrar�rw�feature_untied�s"��
�z_Feature.feature_untiedcs^��fdd��t|t�st|�dkr�|�}|��|S��|�}�fdd�|D�}��|�S)z�
        same as `feature_implies_c()` but stop collecting implied
        features when feature's option that provided through
        parameter 'keyisfalse' is False, also sorting the returned
        features.
        csV��|�}�j|dd�}t|�D]\}}�j|��d�s(|d|d�}|Sq|S)NTr�r)r�r�rgr�r�)�tnamesrpr�)�
keyisfalserqrarw�til�s
�z%_Feature.feature_get_til.<locals>.tilrcsh|]}�|�D]}|�qqSrara)r�r��t)r�rarw�	<setcomp>�sz+_Feature.feature_get_til.<locals>.<setcomp>)r�r�r�r�r�r�)rqr�r�ra)r�rqr�rw�feature_get_til�s


z_Feature.feature_get_tilc	CsB|�|d�}g}|D]}|j|}||�d|�d|g��7}q
|S)z�
        Return a list of CPU features that required to be detected
        sorted from the lowest to highest interest.
        r*r>r=)r�r�r�)rqr�r>r�r/rararw�feature_detect�s
z_Feature.feature_detectcCsV|�|�|��}g}|D]}|j|}|�dg�}|r |�|�s!q||7}q|�|�S)zi
        Return a list of CPU features flags sorted from the lowest
        to highest interest.
        r^)r�r�r�r�rLr])rqr�r^r�r/r1rararw�
feature_flags�s


z_Feature.feature_flagscCs�|dur	|�|�}|�d|d�|�f�tj�|jd|���}tj�|�s-|�d|�|j	|||j
d|d�}|sC|jdd	d
�|S)a�
        Test a certain CPU feature against the compiler through its own
        check file.

        Parameters
        ----------
        name : str
            Supported CPU feature name.

        force_flags : list or None, optional
            If None(default), the returned flags from `feature_flags()`
            will be used.

        macros : list of tuples, optional
            A list of C macro definitions.
        Nz$testing feature '%s' with flags (%s)r�zcpu_%s.czfeature test file is not existr�r�rXTr�)r�r�r�r�r�r��lowerrr�r�rJ)rqr�r�r�rYr�rararw�feature_tests$

����z_Feature.feature_testcCsn|��sJ�|dust|t�sJ�||jv}|r5|�|�D]
}|j|||d�s*dSq|j|||d�s5dS|S)a�
        Check if a certain CPU feature is supported by the platform and compiler.

        Parameters
        ----------
        name : str
            CPU feature name in uppercase.

        force_flags : list or None, optional
            If None(default), default compiler flags for every CPU feature will
            be used during test.

        macros : list of tuples, optional
            A list of C macro definitions.
        Nr�F)r�r�r�r�r�r�)rqr�r�r��	supported�implrararwr�+s
�z_Feature.feature_is_supportedcsVt|t�sJ��j|}|�dd�}|dur)�fdd�|�dg�D�}|o(t|�}|S)zM
        check if the feature can be auto-vectorized by the compiler
        r`Ncsg|]}��|g��qSra)rLr�rerarwr�Qs�z0_Feature.feature_can_autovec.<locals>.<listcomp>r^)r�r�r�r��any)rqr�r/�can�valid_flagsrarerw�feature_can_autovecHs


�z_Feature.feature_can_autovecc
Cs�t|t�sJ�|j|}|�dg�}|sgS|�d||�|�|�}g}g}|D]2}tj�|j	d|�
��}tj�|�sC|�d|�|�
|||jd�}	|	rV|�|�q)|�|�q)|rf|jd|dd�|S)	z�
        Return a list of supported extra checks after testing them against
        the compiler.

        Parameters
        ----------
        names : str
            CPU feature name in uppercase.
        r8z%Testing extra checks for feature '%s'z
extra_%s.czextra check file does not existrztesting failed for checksTr�)r�r�r�r�r�r�r�r�r�r�r�rr�r�rJr�)
rqr�r/r8r^�	available�
not_available�chkrY�is_supportedrararw�feature_extra_checksWs,

�z_Feature.feature_extra_checksrcs�|��sJ�|j�|�}|dusJ�d|d|j|fg}|dd�|�dg�D�7}|�dg�}||�|�7}|D]}|d|j|fd	|j|fd
g7}q9�dkrZ�fdd�|D�}d
�|�S)a"
        Generate C preprocessor definitions and include headers of a CPU feature.

        Parameters
        ----------
        'feature_name': str
            CPU feature name in uppercase.
        'tabs': int
            if > 0, align the generated strings to the right depend on number of tabs.

        Returns
        -------
        str, generated C preprocessor

        Examples
        --------
        >>> self.feature_c_preprocessor("SSE3")
        /** SSE3 **/
        #define NPY_HAVE_SSE3 1
        #include <pmmintrin.h>
        Nz
/** %s **/z#define %sHAVE_%s 1cS�g|]}d|�qS)z
#include <%s>ra)r�r rararwr����z3_Feature.feature_c_preprocessor.<locals>.<listcomp>rr=z#ifndef %sHAVE_%sz	#define %sHAVE_%s 1z#endifrcsg|]}d�|�qS)�	ra)r��l��tabsrarwr��r��
)r�r�r�r�r�r�)rqr�r�r��prepr�
extra_defs�edefrar�rw�feature_c_preprocessor~s(�
��
z_Feature.feature_c_preprocessor�F)r)r�r�r�r�r�r�r�r�r�r�r�r�r�r�r	r<r�r�r�r�r�r�rarararwr~�s.
"#

1&)
'

&r~c@s�eZdZdZdd�Zdd�Ze�d�Zdd�Z	e�d	�Z
d
d�Zdd
�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�ZdS)�_Parsea�A helper class that parsing main arguments of `CCompilerOpt`,
    also parsing configuration statements in dispatch-able sources.

    Parameters
    ----------
    cpu_baseline : str or None
        minimal set of required CPU features or special options.

    cpu_dispatch : str or None
        dispatched set of additional CPU features or special options.

    Special options can be:
        - **MIN**: Enables the minimum CPU features that utilized via `_Config.conf_min_features`
        - **MAX**: Enables all supported CPU features by the Compiler and platform.
        - **NATIVE**: Enables all CPU features that supported by the current machine.
        - **NONE**: Enables nothing
        - **Operand +/-**: remove or add features, useful with options **MAX**, **MIN** and **NATIVE**.
            NOTE: operand + is only added for nominal reason.

    NOTES:
        - Case-insensitive among all CPU features and special options.
        - Comma or space can be used as a separator.
        - If the CPU feature is not supported by the user platform or compiler,
          it will be skipped rather than raising a fatal error.
        - Any specified CPU features to 'cpu_dispatch' will be skipped if its part of CPU baseline features
        - 'cpu_baseline' force enables implied features.

    Attributes
    ----------
    parse_baseline_names : list
        Final CPU baseline's feature names(sorted from low to high)
    parse_baseline_flags : list
        Compiler flags of baseline features
    parse_dispatch_names : list
        Final CPU dispatch-able feature names(sorted from low to high)
    parse_target_groups : dict
        Dictionary containing initialized target groups that configured
        through class attribute `conf_target_groups`.

        The key is represent the group name and value is a tuple
        contains three items :
            - bool, True if group has the 'baseline' option.
            - list, list of CPU features.
            - list, list of extra compiler flags.

    cs�td�jgf�j�jgf�jdgf�jdgf�jddgfd��_t�d�r'dSg�_	g�_
g�_i�_�j
r:d}}��d�|dur]��d|�}��|�}��|��_
����|���_	��d�|dur���d|�}�fdd	�|D�}|�|�}����|���_t|�d
kr���d|d���d
��j��D]-\}}��d|�|��}|r�|��s�dggf�j|<q���|�\}	}
}|	|
|f�j|<q�d�_dS)N�MAXOPT)�
KEEP_BASELINE�	KEEP_SORTr��WERROR�AUTOVEC�parse_is_cachedzcheck requested baseline�cpu_baselinez&check requested dispatch-able features�cpu_dispatchcsh|]	}|�jvr|�qSra��parse_baseline_namesr�rerarwr�s

�z"_Parse.__init__.<locals>.<setcomp>rz
skip featureszsince its part of baselinezinitialize targets groupszparse target groupFT)rh�_parse_policy_not_keepbase�_parse_policy_keepsort�_parse_policy_not_keepsort�_parse_policy_maxopt�_parse_policy_werror�_parse_policy_autovec�_parse_policiesr�r��parse_baseline_flags�parse_dispatch_names�parse_target_groupsrbr��_parse_arg_featuresr�r�r�r��
differencer�r�rr��strip�_parse_target_tokensr�)rqr�r��baseline_names�
cpu_dispatch_�conflict_baseline�
group_namerc�
GROUP_NAME�has_baseline�features�extra_flagsrarerwr��sz������


�

�
��

���
z_Parse.__init__cCs|�d|�t|��U}d}d}d}d}d}d}t|�D]<\}	}
|	|kr*|�d�n.|dkr>|
�|�}|dkr8q|t|�7}||
7}|
�|�}|dkrW|t|�t|
�7}nqWd�n1sbwY|dkrr|�d	|�|dkr}|�d
|�|||�}|�|�S)a�
        Fetch and parse configuration statements that required for
        defining the targeted CPU features, statements should be declared
        in the top of source in between **C** comment and start
        with a special mark **@targets**.

        Configuration statements are sort of keywords representing
        CPU features names, group of statements and policies, combined
        together to determine the required optimization.

        Parameters
        ----------
        source : str
            the path of **C** source file.

        Returns
        -------
        - bool, True if group has the 'baseline' option
        - list, list of CPU features
        - list, list of extra compiler flags
        z!looking for '@targets' inside -> ri�z@targets���z*/zreached the max of linesNz(expected to find '%s' within a C commentzexpected to end with '%s')r�r)rgr��findr�r�)rqr�rZrc�max_to_reach�
start_with�	start_pos�end_with�end_pos�current_line�linerararw�
parse_targets0s>



���
z_Parse.parse_targetsz\s|,|([+-])c
Cs:t|t�s|�d|�t�}ttdt�|j|���}d}|D]{}|ddvr-|�|d�|dkr4d}q|dkr;d}q|�	�}t�}|d	krGnD|d
kra|j
d}	|	sX|�|d�|j|	d
gd�}n*|dkrk|j�
�}n |dkrs|j}n||jvr~|�|�n
|�|�s�|�|d|�|r�|�|�}n|�|�}d}q|S)Nzexpected a string in '%s'Tr)�#�$zYtarget groups and policies aren't allowed from arguments, only from dispatch-able sourcesr^�-F�NONE�NATIVErz-native option isn't supported by the compiler)�DETECT_FEATURESrr��MAX�MINz&, '%s' isn't a known feature or option)r�r�r�rr�rjr�rK�_parse_regex_argr�rJr�r�r%r�rnr�r�r�)
rq�arg_name�req_features�final_featuresrcr��tok�TOK�features_torrararwr�gsX
�
��

�
z_Parse._parse_arg_featuresz\s|[*,/]|([()])cCs�t|t�sJ�g}g}d}t�}t�}d}ttdt�|j|���}|s(|�d�|D]�}|�	�}	|d}
|
dvr>|�d�q*|
dkrT|durK|�d�|�
|�|	��q*|
dkrm|dura|�d	�|�|	|||�\}}}q*|
d
kr~|durz|�d�t�}q*|
dkr�|dur�|�d
�|�
|�}|dur�|�
t|��nt|�dkr�|d}|r�||vr�|�|�d}q*|	dkr�|dur�|�d�d}q*|dur�|�
|	�q*|�|	�s�|�d|	�|	|jvp�|	|jv}|r�|	|vr�|�|	�q*|�
|	�q*|dur�|�d�|�r	|�d|d�|�|�}t|�D]&}
|j|
\}}}|D]}||v�r'�q|�d|
|f�|�
|��q�q|j��D])\}
\}}}d}|
|v�rV|}|�d|
�n|}|�s]�q>||||�\}}}�q>|||fS)NFzexpected one token at leastr)r^rze+/- are 'not' allowed from target's groups or @targets, only from cpu_baseline and cpu_dispatch parmsrzCpolicies aren't allowed inside multi-target '()', only CPU featuresrzHtarget groups aren't allowed inside multi-target '()', only CPU featuresr�z"unclosed multi-target, missing ')'r�z$multi-target opener '(' wasn't foundr�BASELINEz/baseline isn't allowed inside multi-target '()'Tzinvalid target name '%s'zskip targetsz.not part of baseline or dispatch-able featureszpolicy '%s' force enables '%s'zpolicy '%s' is ON)r�r�rr�rjr�rK�_parse_regex_targetr�r�rn�_parse_token_policy�_parse_token_group�_parse_multi_target�tupler�r�r�r�r�r�r�r�r)rqrc�
final_targetsr�r��skipped�policies�multi_targetrr�ch�targets�
is_enabled�prx�depsr/�have�nhave�funcrararwr��s�
���
�







�

�

���

�
z_Parse._parse_target_tokenscCsZt|�dks|dd�|dkr|�d�|dd�}||jvr+|�d||j���|S)zvalidate policy tokenrr�Nrz*'$' must stuck in the begin of policy namez6'%s' is an invalid policy name, available policies are)r�r�r�r%)rq�tokenrararwrs 

�z_Parse._parse_token_policycs�t|�dks|dd�|dkr|�d�|dd�}|j�|ddgf�\}}}|dur9|�d|d|j���|r=d	}��fd
d�|D�7���fdd�|D�7�|��fS)
zvalidate group tokenrr�Nrz)'#' must stuck in the begin of group nameFz&'%s' is an invalid target group name, zavailable target groups areTcr�rarar�)rrarwr�2r�z-_Parse._parse_token_group.<locals>.<listcomp>cr�rarar�)r�rarwr�3r�)r�r�r�r�r%)rqr$r�rr��
ghas_baseline�gtargets�gextra_flagsra)r�rrwr s$ 


���
z_Parse._parse_token_groupcsr|s��d�t�fdd�|D��s��d|�t�fdd�|D��s%dS��|�}|s.dS��|�}t|�}|S)z9validate multi targets that defined between parentheses()zempty multi-target '()'c�g|]}��|��qSra)r��r��tarrerarwr�;s
�z._Parse._parse_multi_target.<locals>.<listcomp>z#invalid target name in multi-targetcs g|]}|�jvp
|�jv�qSra)r�r�r)rerarwr�?s

��N)r��allr�r�r)rqrrarerwr6s 
��

z_Parse._parse_multi_targetcsxg}|dd�D]&}d}t|t�r|�jv}nt�fdd�|D��}|r.|�|�|�|�q|r7��d|�|||fS)zskip all baseline featuresNFcsg|]}|�jv�qSrar�r�rerarwr�X���z5_Parse._parse_policy_not_keepbase.<locals>.<listcomp>zskip baseline features)r�r�r�r+r�r�r�)rqr�rr�rr*�is_baserarerwr�Os
�

�
z!_Parse._parse_policy_not_keepbasecCs|�d|d�|||fS)z$leave a notice that $keep_sort is onz/policy 'keep_sort' is on, dispatch-able targetszo
are 'not' sorted depend on the highest interest butas specified in the dispatch-able source or the extra group)r��rqr�rr�rararwr�es�
z_Parse._parse_policy_keepsortcCs|j|dd�}|||fS)z%sorted depend on the highest interestTr�)r�r.rararwr�ns
z!_Parse._parse_policy_not_keepsortcCsT|jr	|�d�n|jr|�d�n|jd}|s!|jddd�n||7}|||fS)z&append the compiler optimization flagsz3debug mode is detected, policy 'maxopt' is skipped.z5optimization is disabled, policy 'maxopt' is skipped.rzOcurrent compiler doesn't support optimization flags, policy 'maxopt' is skippedTr�)rAr�rbrJ�rqr�rr�r^rararwr�ss
�
z_Parse._parse_policy_maxoptcCs:|jd}|s|jddd�n	|�d�||7}|||fS)z#force warnings to treated as errorsrzTcurrent compiler doesn't support werror flags, warnings will 'not' treated as errorsTr�z'compiler warnings are treated as errors)rJr�r/rararwr��s
�

z_Parse._parse_policy_werrorcstg}|dd�D]$}t|t�r��|�}nt�fdd�|D��}|s,|�|�|�|�q|r5��d|�|||fS)z=skip features that has no auto-vectorized support by compilerNcr(ra)r��r�r�rerarwr��r,z0_Parse._parse_policy_autovec.<locals>.<listcomp>z!skip non auto-vectorized features)r�r�r�r+r�r�r�)rqr�rr�rr*r�rarerwr��s
�

�
z_Parse._parse_policy_autovecN)r�r�r�r�r�rr�r�rr�rr�rrrr�r�r�r�r�r�rarararwr��s".R
6
8t	
r�c@sjeZdZdZddd�Zdd�Zd	d
�Zdd�Zd
d�Zddd�Z	dd�Z
ddd�Zddd�Zddd�Z
dS)�CCompilerOptz�
    A helper class for `CCompiler` aims to provide extra build options
    to effectively control of compiler optimizations that are directly
    related to CPU features.
    �minr�NcCs�t�|�t�||�t�|||��||�t�|�t�|�|js-|jr-|�	d�d}t
�|||�||_||_t
|di�|_|j�d�t|d�|_dS)NzSnative flag is specified through environment variables. force cpu-baseline='native'r�sources_status�	hit_cache)rr�r�r	r�r=r~rbrBr�r��_requested_baseline�_requested_dispatchr�r3rrnr�r4)rqr�r�r�rrararwr��s 


�zCCompilerOpt.__init__cCs|jo|jS)zF
        Returns True if the class loaded from the cache file
        )rr4rerararw�	is_cached�szCCompilerOpt.is_cachedcC�|jS)zE
        Returns a list of final CPU baseline compiler flags
        )r�rerararw�cpu_baseline_flags��zCCompilerOpt.cpu_baseline_flagscCr8)zC
        return a list of final CPU baseline feature names
        r�rerararw�cpu_baseline_names�r:zCCompilerOpt.cpu_baseline_namescCr8)zC
        return a list of final CPU dispatch feature names
        )r�rerararw�cpu_dispatch_names�r:zCCompilerOpt.cpu_dispatch_namescKs&i}|��}|�dg�}|D]g}tj�|�}	|r-|	�|�s$tj�||	�}	|	|vr-|�|	�|�|�\}
}}|�	|	|||
�}
|D]}|j
|	|||
d�}t||�|��}|�|g��|�q?|
rnt||�}|�|g��|�|
|f|j
|<qg}|��D]\}}||j|t|�fd|i|��7}q||S)a�
        Compile one or more dispatch-able sources and generates object files,
        also generates abstract C config headers and macros that
        used later for the final runtime dispatching process.

        The mechanism behind it is to takes each source file that specified
        in 'sources' and branching it into several files depend on
        special configuration statements that must be declared in the
        top of each source which contains targeted CPU features,
        then it compiles every branched source with the proper compiler flags.

        Parameters
        ----------
        sources : list
            Must be a list of dispatch-able sources file paths,
            and configuration statements must be declared inside
            each file.

        src_dir : str
            Path of parent directory for the generated headers and wrapped sources.
            If None(default) the files will generated in-place.

        ccompiler : CCompiler
            Distutils `CCompiler` instance to be used for compilation.
            If None (default), the provided instance during the initialization
            will be used instead.

        **kwargs : any
            Arguments to pass on to the `CCompiler.compile()`

        Returns
        -------
        list : generated object files

        Raises
        ------
        CompileError
            Raises by `CCompiler.compile()` on compiling failure.
        DistutilsError
            Some errors during checking the sanity of configuration statements.

        See Also
        --------
        parse_targets :
            Parsing the configuration statements of dispatch-able sources.
        �include_dirs)�nochanger�)r9�
setdefaultr�r�r��
startswithr�r�r�_generate_config�_wrap_targetrr�r3rr�r�)rqr��src_dirr�r��
to_compile�baseline_flagsr=�srcr�r�rr�r>r*�tar_srcr^�objects�srcsrararw�try_dispatch�s</

��
�zCCompilerOpt.try_dispatchc
sn��d|����}���}t|�}t|�}tj�|�}tj�|�s3�jd|�d�dd�t�|�t	|d��u}d�
�fdd	�|D��}d�
�fd
d	�|D��}	|�t�
d�j�jd�
|�d�
|�||||	d
��d}
|D]
}|
�j|dd�d7}
qnd}|D]}|t�
d�j�j|�j|dd�d�7}q�|�t�
d�j�j|
|d��Wd�dS1s�wYdS)ax
        Generate the dispatch header which contains the #definitions and headers
        for platform-specific instruction-sets for the enabled CPU baseline and
        dispatch-able features.

        Its highly recommended to take a look at the generated header
        also the generated source files via `try_dispatch()`
        in order to get the full picture.
        z"generate CPU dispatch header: (%s)zdispatch header dir z does not exist, creating itTr�r#� \
c�g|]	}d�j|f�qS�z3	%sWITH_CPU_EXPAND_(MACRO_TO_CALL(%s, __VA_ARGS__))�r�r�rerarwr�N	����z9CCompilerOpt.generate_dispatch_header.<locals>.<listcomp>crLrMrNr�rerarwr�T	rOa�                /*
                 * AUTOGENERATED DON'T EDIT
                 * Please make changes to the code generator (distutils/ccompiler_opt.py)
                */
                #define {pfx}WITH_CPU_BASELINE  "{baseline_str}"
                #define {pfx}WITH_CPU_DISPATCH  "{dispatch_str}"
                #define {pfx}WITH_CPU_BASELINE_N {baseline_len}
                #define {pfx}WITH_CPU_DISPATCH_N {dispatch_len}
                #define {pfx}WITH_CPU_EXPAND_(X) X
                #define {pfx}WITH_CPU_BASELINE_CALL(MACRO_TO_CALL, ...) \
                {baseline_calls}
                #define {pfx}WITH_CPU_DISPATCH_CALL(MACRO_TO_CALL, ...) \
                {dispatch_calls}
            r�)�pfx�baseline_str�dispatch_str�baseline_len�dispatch_len�baseline_calls�dispatch_callsrrr�r�z�                #ifdef {pfx}CPU_TARGET_{name}
                {pre}
                #endif /*{pfx}CPU_TARGET_{name}*/
                )rPr��prez�            /******* baseline features *******/
            {baseline_pre}
            /******* dispatch features *******/
            {dispatch_pre}
            )rP�baseline_pre�dispatch_preN)r�r;r<r�r�r�r�rr&r)r�r*r+r,r-r�r�r�)
rq�header_pathr��dispatch_namesrSrT�
header_dirr1rUrVrXr�rYrarerw�generate_dispatch_header4	sV

�
��
�

�
�	
�"�z%CCompilerOpt.generate_dispatch_headerFc Cs�g}g}g}g}|�d|f�|�d�|�d|f�|�d�|�d|f�|�d|jr/dn|jf�|�d|jr<dn|jf�|jrJ|�d	�n
|�d
t|j�f�|��}|�d|rbd�	|�nd
f�|�
�}|�d|rtd�	|�nd
f�g}|D]	}	||�|	�7}q||�d|r�d�	|�nd
f�|jr�|�d	�n
|�d
t|j�f�|�
�}
|�d|
r�d�	|
�nd
f�i}|j��D]\}\}
}|D]}|�|g��|�q�q�|r�|�sd}|�|�D]}||}t|t�r�|ndd�	|�}	||	dt|�7}q�|�d|�r|dd�nd
f�n�|�d�|�|�D]�}||}t|t��r)|ndd�	|�}d�	|�|��}d�	|�|�|���}d�	|�|��}g}t|t��rV|fn|D]
}	||�|	�7}�qX|�rkd�	|�nd
}|�d�|�||f�|�d|f�|�d|f�|�d|f�|D]
}|�d|f��q��qg}dd�|D�}dd�|D�}d}tt|�t|��}|D]?\}}|�s�|�d��q�|d|t|�7}|�||d�|D]\}}|d|t|�7}|�||d|��qݐq�d�	|�S)N�Platform)rrzCPU baselinezCPU dispatch�Architecture�unsupported�Compilerz	unix-like)�	Requestedzoptimization disabledrb�Enabledr��none�FlagszExtra checksrz(%s)z[%d] �	Generatedr�)rfr�DetectcSsg|]\}}t|��qSra�r�)r��secsrxrararwr��	r�z'CCompilerOpt.report.<locals>.<listcomp>cSs&g|]\}}|D]\}}t|��qqSrarh)r�rx�rows�colrararwr��	s&z  z: r�)r�r?rHr@rIrb�reprr5r;r�r9r�r6r<r3rr?r�r�r�r�r�r�r�r�) rq�full�report�
platform_rows�
baseline_rows�
dispatch_rowsr�rEr8r�r[�target_sourcesr�rxrr*�	generatedr��pretty_namer^rr>rFr��secs_len�cols_len�tab�pad�secrjrkrrararwrn�	s�

�������
"

�
�
zCCompilerOpt.reportc	st|ttf�s	J�t|t�r|}}n
d�|�}d�|�}tj�|tj�|��}djgtj�|��|�	��R�}|rBtj�
|�rB|S|�d|�|�|�
|��}d|j��fdd�|D�}	d�|	�}	t|d	��}
|
�t�d
�j|j|tj�|�|	d��Wd�|S1s�wY|S)N�.�__z
{0}.{2}{1}zwrap dispatch-able target -> z#define %sCPU_TARGET_csg|]}�|�qSrarar���target_joinrarwr�
sz-CCompilerOpt._wrap_target.<locals>.<listcomp>r�r#aR            /**
             * AUTOGENERATED DON'T EDIT
             * Please make changes to the code generator              (distutils/ccompiler_opt.py)
             */
            #define {pfx}CPU_TARGET_MODE
            #define {pfx}CPU_TARGET_CURRENT {target_name}
            {target_defs}
            #include "{path}"
            )rP�target_namer��target_defs)r�r�rr�r�r��basenamer-�splitextr�rr�r�r�r�r)r*r+r,�abspath)rqr��dispatch_src�targetr>�ext_namer~�	wrap_pathr�rrZrar|rwrB�	s0



 



�
��zCCompilerOpt._wrap_targetc	Cs�tj�|�}tj�|�dd}tj�||�}|�||�}z5t|��'}|���d�}t	|�dkrBt
|d�|krB	Wd�WdSWd�n1sLwYWn	ty[Ynwtjtj�
|�dd�|�d|�g}	|D].}
t|
t�r{|
}n
d	�d
d�|
D��}|�|
�}d�d
d�|D��}|	�d|j||f�qqd�|	�}	|r�d|j}
nd}
t|d��}|�t�d�j|j|
|	|d��Wd�dS1s�wYdS)Nrz.hzcache_hash:rrT)�exist_okzgenerate dispatched config -> r{cSsg|]}|�qSrarar0rararwr�0
sz1CCompilerOpt._generate_config.<locals>.<listcomp>z&&cSr�)zCHK(%s)rar�rararwr�2
r�z2	%sCPU_DISPATCH_EXPAND_(CB((%s), %s, __VA_ARGS__))rKz(	%sCPU_DISPATCH_EXPAND_(CB(__VA_ARGS__))rr#aZ            // cache_hash:{cache_hash}
            /**
             * AUTOGENERATED DON'T EDIT
             * Please make changes to the code generator (distutils/ccompiler_opt.py)
             */
            #ifndef {pfx}CPU_DISPATCH_EXPAND_
                #define {pfx}CPU_DISPATCH_EXPAND_(X) X
            #endif
            #undef {pfx}CPU_DISPATCH_BASELINE_CALL
            #undef {pfx}CPU_DISPATCH_CALL
            #define {pfx}CPU_DISPATCH_BASELINE_CALL(CB, ...) \
            {baseline_calls}
            #define {pfx}CPU_DISPATCH_CALL(CHK, CB, ...) \
            {dispatch_calls}
            )rPrUrVrF)r�r�r�r�r�rr)�readlinerKr��intr{r&r�r�r�r�r�r�r�r*r+r,r-)rqr�r�rr��config_pathrr1�	last_hashrVr*r~�
req_detectrUrZrararwrA
s`
����


���
�
�
��zCCompilerOpt._generate_config)r2r�N)NNr�)r�r�r�r�r�r7r9r;r<rJr]rnrBrArarararwr1�s

W
S
m&r1cKs2t|fi|��}tj�|�r|��s|�|�|S)a�
    Create a new instance of 'CCompilerOpt' and generate the dispatch header
    which contains the #definitions and headers of platform-specific instruction-sets for
    the enabled CPU baseline and dispatch-able features.

    Parameters
    ----------
    compiler : CCompiler instance
    dispatch_hpath : str
        path of the dispatch header

    **kwargs: passed as-is to `CCompilerOpt(...)`
    Returns
    -------
    new instance of CCompilerOpt
    )r1r�r�rr7r])r��dispatch_hpathr�rrararw�new_ccompiler_optX
s
r�)r�r�r�r�r'r�r�r+rr�rr	r=r~r�r1r�rarararw�<module>sD
?;	;hy6