U
    9%eY                     @   sx  d Z ddlmZ ddlmZ ddlZddlZddlmZ ddl	m
Z
mZmZ ddlmZmZ edd	d
gZeddZedZedZeZdd ZedZedZedZedZdZeeZG dd deZG dd deZG dd deZ dZ!dZ"dZ#dZ$dZ%e&eeeeegZ'e(e'Z)G dd deZ*G d d! d!eZ+G d"d# d#e+Z,G d$d% d%e+Z-e,e-d&Z.d'd( Z/dS ))z3
Calling conventions for Numba-compiled functions.
    )
namedtuple)IterableN)ir)typescgutilserrors)PYOBJECTGENERIC_POINTER	TryStatusin_tryexcinfoStatus)codeis_okis_noneis_erroris_stop_iterationis_python_excis_user_exc
excinfoptr    @   c                 C   s   t t| S N)r   Constant	errcode_t)r    r   R/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/numba/core/callconv.py
_const_int+   s    r      c                   @   sl   e Zd Zdd Zdd Zdd Zdd Zd	d
 Zdd Zdd Z	dd Z
dd Zdd Zdd Zdd ZdS )BaseCallConvc                 C   s
   || _ d S r   )context)selfr#   r   r   r   __init__<   s    zBaseCallConv.__init__c              	   C   s   |t jkr| | n||kr| jj|||d}t||j}||& | j	||j
|j}| || W 5 Q R X | | n\t|t js||j
kr| jj||||j
d}| j	||j
|}| || ntd||d S )N)value)ZfromtyZtotyzreturning {0} for {1})r   nonereturn_native_noner#   Zmake_helperr   Zas_bool_bitZvalidif_thenZget_return_valuetypedatareturn_value
isinstanceOptionalcastNotImplementedErrorformat)r$   builderrettyZvaltyr&   optvalZvalidbitretvalr   r   r   return_optional_value?   s*    

z"BaseCallConv.return_optional_valuec                 C   s   |  |t d S r   )_return_errcode_rawRETCODE_NONEr$   r2   r   r   r   r(   \   s    zBaseCallConv.return_native_nonec                 C   s   |  |t d S r   )r7   RETCODE_EXCr9   r   r   r   
return_exc_   s    zBaseCallConv.return_excc                 C   s   |  |t d S r   )r7   RETCODE_STOPITr9   r   r   r   return_stop_iterationb   s    z"BaseCallConv.return_stop_iterationc                 C   s   | j j|  }| S )zQ
        Get the actual type of the return argument for Numba type *ty*.
        )r#   data_model_managerget_return_type
as_pointer)r$   tyrestyper   r   r   r?   e   s    zBaseCallConv.get_return_typec                 C   s   |  |}||_|S )zS
        Initialize and return a call helper object for the given builder.
        )_make_call_helper_BaseCallConv__call_helper)r$   r2   chr   r   r   init_call_helperl   s    
zBaseCallConv.init_call_helperc                 C   s   |j S r   )rD   r9   r   r   r   _get_call_helpert   s    zBaseCallConv._get_call_helperc                 C   s   | |jS r   )unserializer   )r$   r2   pyapistatusr   r   r   unpack_exceptionw   s    zBaseCallConv.unpack_exceptionc              
   C   s   |j  }||jP |  | |||}t|t|| |	| W 5 Q R X |
| W 5 Q R X ||j |d |
| W 5 Q R X ||j |
| W 5 Q R X |dd |
| || dS )zT
        Given a non-ok *status*, raise the corresponding Python exception.
        ZPyExc_StopIterationZPyExc_SystemErrorz*unknown error when calling native functionN)functionappend_basic_blockr)   r   Z	err_clearrK   r   Z	if_likelyZis_not_nullZraise_objectbranchr   Zerr_set_noner   err_set_stringZposition_at_end)r$   r2   rI   rJ   Zbbendexcr   r   r   raise_errorz   s&    



zBaseCallConv.raise_errorc                 C   s    |  |}| |}|||S )z
        Get the decoded (unpacked) Python arguments with *argtypes*
        from LLVM function *func*.  A tuple of LLVM values is returned.
        )get_arguments_get_arg_packerZfrom_arguments)r$   r2   argtypesfuncZraw_argsarginfor   r   r   decode_arguments   s    

zBaseCallConv.decode_argumentsc                 C   s   | j |S )zF
        Get an argument packer for the given argument types.
        )r#   Zget_arg_packer)r$   rT   r   r   r   rS      s    zBaseCallConv._get_arg_packerN)__name__
__module____qualname__r%   r6   r(   r;   r=   r?   rF   rG   rK   rQ   rW   rS   r   r   r   r   r"   :   s   	r"   c                   @   sd   e Zd ZdZdd Zdd ZdddZd	d
 Zdd Zdd Z	dd Z
dddZdd Zdd ZdS )MinimalCallConva  
    A minimal calling convention, suitable for e.g. GPU targets.
    The implemented function signature is:

        retcode_t (<Python return type>*, ... <Python arguments>)

    The return code will be one of the RETCODE_* constants or a
    function-specific user exception id (>= RETCODE_USEREXC).

    Caller is responsible for allocating a slot for the return value
    (passed as a pointer in the first argument).
    c                 C   s   t  S r   )_MinimalCallHelperr9   r   r   r   rC      s    z!MinimalCallConv._make_call_helperc                 C   sP   |j jd }|j|jjks4tt|jt|jjf||| | |t d S Nr   )	rL   argsr*   pointeeAssertionErrorstrstorer7   
RETCODE_OKr$   r2   r5   retptrr   r   r   r,      s    zMinimalCallConv.return_valueNc           
      C   s   |d k	r t |ts td|f |d k	r@t|ts@td|f |d k	rx| }|d kr\|}||j|jf}d |kr|d }nd }| |}|	|||}	| 
|t|	 d S )N-exc should be None or exception class, got %r(exc_args should be None or tuple, got %r)
issubclassBaseException	TypeErrorr-   tuple_raw_function_namefilenamelinerG   _add_exceptionr7   r   )
r$   r2   rP   exc_argsloc	func_namefnamelocinfoZcall_helperexc_idr   r   r   return_user_exc   s&    
zMinimalCallConv.return_user_excc                 C   s   |  ||j d S r   )r7   r   )r$   r2   rJ   r   r   r   return_status_propagate   s    z'MinimalCallConv.return_status_propagatec                 C   s    t |trt|}|| d S r   )r-   intr   retr$   r2   r   r   r   r   r7      s    
z#MinimalCallConv._return_errcode_rawc              
   C   sx   | d|t}| d|t}|||}||}| d|t}| d|t}| d|t}	t||||||	|dd}
|
S )z?
        Given a return *code*, get a Status instance.
        ==>=Nr   r   r   r   r   r   r   r   )	icmp_signedrc   r8   or_not_r:   r<   RETCODE_USEREXCr   )r$   r2   r   normr'   okerrrP   r   r   rJ   r   r   r   _get_return_status   s"    
z"MinimalCallConv._get_return_statusc                 C   s4   |  |}t|j}| |}tt|g| }|S zQ
        Get the implemented Function type for *restype* and *argtypes*.
        )rS   listargument_typesr?   r   FunctionTyper   r$   rB   rT   rV   Zresptrfntyr   r   r   get_function_type   s
    


z!MinimalCallConv.get_function_typeFc                 C   s>   |rt | |}|| |dd |D  d|jd _dS )zA
        Set names and attributes of function arguments.
        c                 S   s   g | ]}d | qS zarg.r   .0ar   r   r   
<listcomp>	  s     z5MinimalCallConv.decorate_function.<locals>.<listcomp>z.retr   N)r`   rS   assign_namesrR   r^   name)r$   fnr^   fe_argtypesnoaliasrV   r   r   r   decorate_function  s    
z!MinimalCallConv.decorate_functionc                 C   s   |j dd S )@
        Get the Python-level arguments of LLVM *func*.
        r!   Nr^   r$   rU   r   r   r   rR     s    zMinimalCallConv.get_argumentsc                 C   s   |j d jj}t||}|t|| | |}|||}|gt	| }	|
||	}
| ||
}||}| j|||}||fS )z3
        Call the Numba-compiled *callee*.
        r   )r^   r*   r_   r   alloca_oncerb   get_null_valuerS   as_argumentsr   callr   loadr#   get_returned_value)r$   r2   calleerestyargtysr^   r3   	retvaltmprV   realargsr   rJ   r5   outr   r   r   call_function  s    

zMinimalCallConv.call_function)NNN)F)rX   rY   rZ   __doc__rC   r,   rv   rw   r7   r   r   r   rR   r   r   r   r   r   r[      s     



r[   c                   @   s(   e Zd ZdZdd Zdd Zdd ZdS )	r\   z
    A call helper object for the "minimal" calling convention.
    User exceptions are represented as integer codes and stored in
    a mapping for retrieval from the caller.
    c                 C   s
   i | _ d S r   )
exceptionsr$   r   r   r   r%   ,  s    z_MinimalCallHelper.__init__c                 C   s"   t | jt }|||f| j|< |S )aV  
        Add a new user exception to this helper. Returns an integer that can be
        used to refer to the added exception in future.

        Parameters
        ----------
        exc :
            exception type
        exc_args : None or tuple
            exception args
        locinfo : tuple
            location information
        )lenr   FIRST_USEREXC)r$   rP   rp   rt   ru   r   r   r   ro   /  s    z!_MinimalCallHelper._add_exceptionc                 C   sF   z| j | W S  tk
r@   d| }t}|f}d}|||f Y S X dS )z
        Get information about a user exception. Returns a tuple of
        (exception type, exception args, location information).

        Parameters
        ----------
        id : integer
            The ID of the exception to look up
        z#unknown error %d in native functionN)r   KeyErrorSystemError)r$   ru   msgrP   rp   rt   r   r   r   get_exceptionA  s    
z _MinimalCallHelper.get_exceptionN)rX   rY   rZ   r   r%   ro   r   r   r   r   r   r\   %  s   r\            c                   @   s   e Zd ZdZedZdd Zdd Zdd Z	d5d
dZ
d6ddZdd Zdd Zdd Zdd Zd7ddZd8ddZdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd9d+d,Zd-d. Zd/d0 Zd1d2 Zd:d3d4Zd	S );CPUCallConva  
    The calling convention for CPU targets.
    The implemented function signature is:

        retcode_t (<Python return type>*, excinfo **, ... <Python arguments>)

    The return code will be one of the RETCODE_* constants.
    If RETCODE_USEREXC, the exception info pointer will be filled with
    a pointer to a constant struct describing the raised exception.

    Caller is responsible for allocating slots for the return value
    and the exception info pointer (passed as first and second arguments,
    respectively).
    r!   c                 C   s   d S r   r   r9   r   r   r   rC   r  s    zCPUCallConv._make_call_helperc                 C   sP   |  |j}|j|jjks4tt|jt|jjf||| | |t d S r   )	_get_return_argumentrL   r*   r_   r`   ra   rb   r7   rc   rd   r   r   r   r,   u  s    zCPUCallConv.return_valuec                 C   sJ   |d k	r8|  }|d kr|}||j|jf}d |kr<d }nd }|||f}|S r   )rl   rm   rn   )r$   rP   rp   rq   rr   rs   rt   r   r   r   build_excinfo_struct|  s    
z CPUCallConv.build_excinfo_structNc                 C   s   |d k	r t |ts td|f |d k	r@t|ts@td|f |d krNt }| j|}| ||||}||}| 	|j
}|||}	|jtddg}
|	d|
 d S )Nrf   rg   r!   Znumba_exception_output)rh   ri   rj   r-   rk   r#   get_python_apir   serialize_object_get_excinfo_argumentrL   rb   moduleadd_metadatar   IntTypeZset_metadata)r$   r2   rP   rp   rq   rr   rI   	struct_gvexcptrrb   mdr   r   r   set_static_user_exc  s"    %
zCPUCallConv.set_static_user_excc                 C   sN   t |dd}| j|||||d | | |r>||d  n| |t d S )NZ_in_try_blockF)rp   rq   rr   target)getattrr   check_try_statusrN   r7   r   )r$   r2   rP   rp   rq   rr   Ztry_infor   r   r   rv     s    
 
zCPUCallConv.return_user_excc              	   C   s*  |j }|||t}|||t}|||||j}|||t}|||t	}	t
ttg}
||	|
 }|||g}t||}t||H d}|d| |jj}
t|
jt
js|t|
j n|  W 5 Q R X |||}| jjr&| jj !||||j" |S )Nz<Error creating Python tuple from runtime exception argumentsZPyExc_RuntimeError)#r   extract_valuer   PICKLE_BUF_IDXPICKLE_BUFSZ_IDXZbytes_from_string_and_sizeZsext
py_ssize_tHASH_BUF_IDXUNWRAP_FUNC_IDXr   r   r   r	   bitcastr@   r   r   Zis_nullZif_unlikelyrO   rL   function_typer-   return_typeZVoidTypery   r   Zret_voidZbuild_dynamic_excinfo_structr#   Z
enable_nrtnrtfreeZvoidptr)r$   r2   rI   rJ   excinfo_ptrZ	picklebufZpicklebuf_szZstatic_exc_bytesZdyn_argsZfunc_ptrr   r   Zpy_tuplefailedr   r   r   r   r   unpack_dynamic_exception  sN         
 z$CPUCallConv.unpack_dynamic_exceptionc              
   C   s   |j }|||t}|d|td}||N\}}| | |||}	|j}
W 5 Q R X | |	|}|j}W 5 Q R X W 5 Q R X |
|j}||	|
 ||| |S )N>r   )r   r   r   ALLOC_FLAG_IDXr~   int32_tZif_elser   blockrH   phir*   Zadd_incoming)r$   r2   rI   rJ   r   Z
alloc_flaggtZthenZ	otherwiseZdyn_excZbb_thenZ
static_excZbb_elser   r   r   r   rK     s     
zCPUCallConv.unpack_exceptionc                 C   s\  t t|  }d| }||jkr6|j|S tt	t	g}t
|||}|jd |jd |d}t|}	| j|	}
| }|	|jd |}dd |D }g }| jj|	dd	}t|D ]\\}}|	|	||}|
j|||d
}|t|jkr d| d}t||| q| jj |	| !|	j" |
#|}|	$| |S )NZ__excinfo_unwrap_argsZnounwindZnoinline r   c                 S   s   g | ]}|d k	r|qS r   r   )r   typr   r   r   r   D  s      z@CPUCallConv.emit_unwrap_dynamic_exception_fn.<locals>.<listcomp>T)Zreturn_pyobject)env_managerzCannot convert native z to a Python object.)%hashlibsha1ra   encode	hexdigestglobalsgetr   r   r	   Function
attributesaddrM   Z	IRBuilderr#   r   r@   r   r^   Zget_env_manager	enumerater   r   Zfrom_native_valuer   r   r*   r   ZTypingErrorappendr   r   r   rL   Z
tuple_packry   )r$   r   Zst_typenb_types_hashr   r   r   Zbb_entryr2   rI   Zst_type_ptrst_ptrZobjsr   ir   valobjr   tupr   r   r    emit_unwrap_dynamic_exception_fn   s>    








z,CPUCallConv.emit_unwrap_dynamic_exception_fnc           
   
   C   sv   | | j|}|| jj||| }dd |D }td}t|D ]$\}}	|	|	|
||t|g qL|S )zP
        Create an anonymous struct containing the given LLVM *values*.
        c                 S   s   g | ]}t |tjr|qS r   )r-   r   Valuer   argr   r   r   r   k  s      z4CPUCallConv.emit_wrap_args_insts.<locals>.<listcomp>r   )r   r#   get_abi_sizeofr   r   allocater@   r   r   rb   gep)
r$   r2   rI   struct_typerp   st_sizer   zeroidxr   r   r   r   emit_wrap_args_insts`  s    z CPUCallConv.emit_wrap_args_instsc              
   C   sL  t |tstd|f |dk	r8t|ts8td|f | j|}| ||||}| |j	}|
||}	tdd |D }
| |||
|}| |j|
|}|| jt}|| jj||t}td}||	t||	t||t||ttt|
f}t|D ]&\}}||| ||t|g q||| dS )zf
        Compute the required bits to emit an exception with dynamic (runtime)
        values
        z(exc should be an exception class, got %rNrg   c                 S   s   g | ]}t |tjr|jqS r   )r-   r   r   r*   r   r   r   r   r     s    z4CPUCallConv.set_dynamic_user_exc.<locals>.<listcomp>r   )!rh   ri   rj   r-   rk   r#   r   r   r   rL   r   r   r   LiteralStructTyper   r   r   r   r   	excinfo_tr   r   r   excinfo_ptr_tr   r   r   r   r	   r   r   rb   r   )r$   r2   rP   rp   r   rq   rr   rI   Z
excinfo_ppr   r   r   Z	unwrap_fnZexc_sizeZ	excinfo_pr   Z
exc_fieldsr   r   r   r   r   set_dynamic_user_excs  sH    
1
  




 z CPUCallConv.set_dynamic_user_excc                 C   s&   | j ||||||d | |t dS )zF
        Same as ::return_user_exc but for dynamic exceptions
        )rq   rr   N)r   r7   r   )r$   r2   rP   rp   r   rq   rr   r   r   r   return_dynamic_user_exc  s
     z#CPUCallConv.return_dynamic_user_excc              	   C   s@   z|j W S  tk
r:   tj|tjddd}||_ | Y S X d S )NZ	try_stateT)r   zfill)Z_CPUCallConv__eh_try_stateAttributeErrorr   r   Zintp_t)r$   r2   Zptrr   r   r   _get_try_state  s       zCPUCallConv._get_try_statec                 C   sJ   |  |}||}|d||d}| |j}||}t||dS )Nr   r   )r   r   )r   r   Zicmp_unsignedr*   r   rL   r
   )r$   r2   try_state_ptrZ	try_depthr   r   r   r   r   r   r     s    


zCPUCallConv.check_try_statusc                 C   s6   |  |}||}|||d}||| d S Nr!   )r   r   r   r*   rb   )r$   r2   r  oldnewr   r   r   set_try_status  s    

zCPUCallConv.set_try_statusc                 C   s\   |  |}||}|||d}||| | |j}t|jj	}||| d S r  )
r   r   subr*   rb   r   rL   r   r   r_   )r$   r2   r  r  r  r   nullr   r   r   unset_try_status  s    

zCPUCallConv.unset_try_statusc              	   C   sT   |  |}| |j}||j| |||j | ||j	 W 5 Q R X d S r   )
r   r   rL   rb   r   r)   r   r   r7   r   )r$   r2   rJ   Z	trystatusr   r   r   r   rw     s
    
z#CPUCallConv.return_status_propagatec                 C   s   | | d S r   )ry   rz   r   r   r   r7     s    zCPUCallConv._return_errcode_rawc              
   C   s   | d|t}| d|t}| d|t}| d|t}|||}||}	| d|t}
||
|t	
tt	j}t|||	|||
||d}|S )zP
        Given a return *code* and *excinfoptr*, get a Status instance.
        r{   r|   r}   )r~   rc   r8   r:   r<   r   r   r   selectr   r   r   	Undefinedr   )r$   r2   r   r   r   r'   rP   r   r   r   r   rJ   r   r   r   r   	  s(    
zCPUCallConv._get_return_statusc                 C   s<   |  |}t|j}| |}tt|ttg| }|S r   )	rS   r   r   r?   r   r   r   PointerTyper   r   r   r   r   r   !  s    


zCPUCallConv.get_function_typeFc                    s     |}| |dd |D   |}d|_|d |d  |}d|_|d |d |r |}|D ]&}t|jt	j
r|d |d q fdd}	tt|	|}
|
r|jd	}||j|g d
S )zU
        Set names of function arguments, and add useful attributes to them.
        c                 S   s   g | ]}d | qS r   r   r   r   r   r   r   3  s     z1CPUCallConv.decorate_function.<locals>.<listcomp>re   Z	nocapturer   r   c                    s(   t | tjs$ jj}||   r$dS dS NTF)r-   r   ZArrayr#   r>   Zcontains_nrt_meminfo)rA   Zdmmr   r   r   type_may_always_need_nrtF  s
    z?CPUCallConv.decorate_function.<locals>.type_may_always_need_nrtZnumba_args_may_always_need_nrtN)rS   r   rR   r   r   Zadd_attributer   r-   r*   r   r  anymapr   Zadd_named_metadatar   r   )r$   r   r^   r   r   rV   ZretargZexcargr   r  Zargs_may_always_need_nrtZnmdr   r   r   r   -  s6    








zCPUCallConv.decorate_functionc                 C   s   |j dd S )r   r   Nr   r   r   r   r   rR   X  s    zCPUCallConv.get_argumentsc                 C   s
   |j d S r]   r   r   r   r   r   r   ^  s    z CPUCallConv._get_return_argumentc                 C   s
   |j d S r  r   r   r   r   r   r   a  s    z!CPUCallConv._get_excinfo_argumentc                 C   s   |  |jj}t||}|t|| tj|tt	dd}	| 
|}
t|
||}||	g| }|dkrvd}n&t|trt|tst|}ntd|j|||d}| ||||	}||}| j|||}||fS )aU  
        Call the Numba-compiled *callee*.
        Parameters:
        -----------
        attrs: LLVM style string or iterable of individual attributes, default
               is None which specifies no attributes. Examples:
               LLVM style string: "noinline fast"
               Equivalent iterable: ("noinline", "fast")
        r   )r   Nr   z,attrs must be an iterable of strings or None)attrs)r   r   r_   r   r   rb   r   r   r  r   rS   r   r   r-   r   ra   rk   rj   r   r   r   r#   r   )r$   r2   r   r   r   r^   r  r3   r   r   rV   r   Z_attrsr   rJ   r5   r   r   r   r   r   d  s*    


zCPUCallConv.call_function)NNN)NNN)NN)NN)F)N)rX   rY   rZ   r   	itertoolscountZ_status_idsrC   r,   r   r   rv   r   rK   r   r   r   r   r   r   r  r  rw   r7   r   r   r   rR   r   r   r   r   r   r   r   r   a  sF   
  
9  
4@  
[   
	

+ r   c                   @   s   e Zd Zdd ZdddZdS )
ErrorModelc                 C   s
   || _ d S r   )	call_conv)r$   r  r   r   r   r%     s    zErrorModel.__init__Nc                 C   s$   | j r| j|t|| dS dS d S r  )raise_on_fp_zero_divisionr  rv   ZeroDivisionError)r$   r2   rp   rq   r   r   r   fp_zero_division  s    zErrorModel.fp_zero_division)NN)rX   rY   rZ   r%   r  r   r   r   r   r    s   r  c                   @   s   e Zd ZdZdZdS )PythonErrorModelzL
    The Python error model.  Any invalid FP input raises an exception.
    TNrX   rY   rZ   r   r  r   r   r   r   r    s   r  c                   @   s   e Zd ZdZdZdS )NumpyErrorModela6  
    In the Numpy error model, floating-point errors don't raise an
    exception.  The FPU exception state is inspected by Numpy at the
    end of a ufunc's execution and a warning is raised if appropriate.

    Note there's no easy way to set the FPU exception state from LLVM.
    Instructions known to set an FP exception can be optimized away:
        https://llvm.org/bugs/show_bug.cgi?id=6050
        http://lists.llvm.org/pipermail/llvm-dev/2014-September/076918.html
        http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20140929/237997.html
    FNr  r   r   r   r   r    s   r  )pythonnumpyc                 C   s   t |  |jS )zF
    Create an error model instance for the given target context.
    )error_modelsr  )Z
model_namer#   r   r   r   create_error_model  s    r  )0r   collectionsr   collections.abcr   r  r   Zllvmliter   Z
numba.corer   r   r   Znumba.core.baser   r	   r
   r   r   r   Zint64_tr   r   rc   r:   r8   r<   r   r   objectr"   r[   r\   r   r   r   r   r   r   r   r  r   r   r  r  r  r  r  r   r   r   r   <module>   sZ   

n}2
    1