o
    ۾i                     @   sh   d dl mZ d dlmZmZ G dd deZG dd deZdd Zd	Z	d
Z
dZdZG dd deZdS )    )deque)typescgutilsc                   @   s:   e Zd ZdZdd Zdd ZdddZd	d
 Zdd ZdS )
DataPackerz
    A helper to pack a number of typed arguments into a data structure.
    Omitted arguments (i.e. values with the type `Omitted`) are automatically
    skipped.
    c                    sp    | _ || _ fdd|D | _g | _g | _t|D ]\}}t|tjs5| j	| | j	| j| 
  qd S )Nc                    s   g | ]}  |qS  )lookup.0tydmmr   O/home/ubuntu/.local/lib/python3.10/site-packages/numba/core/datamodel/packer.py
<listcomp>   s    z'DataPacker.__init__.<locals>.<listcomp>)_dmm	_fe_types_models	_pack_map	_be_types	enumerate
isinstancer   Omittedappendget_data_type)selfr   fe_typesir
   r   r   r   __init__   s   zDataPacker.__init__c                    s$    fddj D }t |S )zE
        Return the given values packed as a data structure.
        c                    s"   g | ]}j |  | qS r   )r   as_data)r	   r   builderr   valuesr   r   r      s    z&DataPacker.as_data.<locals>.<listcomp>)r   r   make_anonymous_struct)r   r   r    elemsr   r   r   r      s   zDataPacker.as_dataNc           	      C   sd   g }t | jD ](\}}t||d|}| j| ||}|d u r+|| j| |f q|||< q|S Nr   )r   r   r   gep_inboundsr   load_from_data_pointerr   r   )	r   r   ptrformal_listresr   i_formalelem_ptrvalr   r   r   _do_load#   s   
zDataPacker._do_loadc                 C   s   |  ||S )zK
        Load the packed values and return a (type, value) tuples.
        r,   )r   r   r&   r   r   r   load.   s   zDataPacker.loadc                 C   s   |  ||| dS )z
        Load the packed values into a sequence indexed by formal
        argument number (skipping any Omitted position).
        Nr-   )r   r   r&   r'   r   r   r   	load_into4   s   zDataPacker.load_intoN)	__name__
__module____qualname____doc__r   r   r,   r.   r/   r   r   r   r   r      s    
r   c                   @   sF   e Zd ZdZdd Zdd Zdd Zdd	 ZdddZe	dd Z
dS )	ArgPackera  
    Compute the position for each high-level typed argument.
    It flattens every composite argument into primitive types.
    It maintains a position map for unflattening the arguments.

    Since struct (esp. nested struct) have specific ABI requirements (e.g.
    alignment, pointer address-space, ...) in different architecture (e.g.
    OpenCL, CUDA), flattening composite argument types simplifes the call
    setup from the Python side.  Functions are receiving simple primitive
    types and there are only a handful of these.
    c                 C   sl   || _ || _t|| _g | _g }|D ]}| j |}| j| ||  qt|| _	t
t|| _d S r0   )r   _fe_argslen_nargs_dm_argsr   r   get_argument_type_Unflattener_unflattenerlist_flatten_be_args)r   r   fe_argsargtysr
   dmr   r   r   r   I   s   

zArgPacker.__init__c                    sV   t || jkrtd| jt |f |sdS  fddt| j|D }tt|}|S )z$Flatten all argument values
        z+invalid number of args: expected %d, got %dr   c                       g | ]
\}}|  |qS r   )as_argumentr	   rB   r+   r   r   r   r   a       z*ArgPacker.as_arguments.<locals>.<listcomp>)r7   r8   	TypeErrorzipr9   tupler>   )r   r   r    argsr   rF   r   as_argumentsW   s   

zArgPacker.as_argumentsc                    s*   | j |} fddt| j|D }|S )z&Unflatten all argument values
        c                    rC   r   )from_argumentrE   rF   r   r   r   m   rG   z,ArgPacker.from_arguments.<locals>.<listcomp>)r<   	unflattenrI   r9   )r   r   rK   valtreer    r   rF   r   from_argumentsh   s
   

zArgPacker.from_argumentsc                 C   s0   | j |}t||D ]
\}}| || qdS )z9Assign names for each flattened argument values.
        N)r<   rN   rI   _assign_names)r   rK   namesrO   avalanamer   r   r   assign_namess   s   zArgPacker.assign_namesr   c                 C   sh   t |ttfrt|D ]\}}| j||||f d qd S dtt|}||g}dtt	||_
d S )N)depth.)r   rJ   r=   r   rQ   joinmapstrfilterboolname)r   val_or_nestedr]   rV   posrS   postfixpartsr   r   r   rQ   {   s   zArgPacker._assign_namesc                 C   s   t dd | jD S )z\Return a list of LLVM types that are results of flattening
        composite types.
        c                 s   s    | ]	}|d kr|V  qdS )r   Nr   r   r   r   r   	<genexpr>   s    z+ArgPacker.argument_types.<locals>.<genexpr>)rJ   r?   )r   r   r   r   argument_types   s   zArgPacker.argument_typesN)r   )r1   r2   r3   r4   r   rL   rP   rU   rQ   propertyrc   r   r   r   r   r5   <   s    
	r5   c                    s    fdd  | S )z3
    Flatten nested iterable of (tuple, list).
    c                 3   s:    | D ]}t |ttfr |D ]}|V  qq|V  qd S r0   )r   rJ   r=   )iterabler   jrecr   r   rh      s   z_flatten.<locals>.recr   )re   r   rg   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
    An object used to unflatten nested sequences after a given pattern
    (an arbitrarily nested sequence).
    The pattern shows the nested sequence shape desired when unflattening;
    the values it contains are irrelevant.
    c                 C   s   |  || _d S r0   )_build_unflatten_code_code)r   patternr   r   r   r      s   z_Unflattener.__init__c                    s   g   fdd|  S )zzBuild the unflatten opcode sequence for the given *iterable* structure
        (an iterable of nested sequences).
        c                    s\   | D ])}t |ttfr&t|dkr  t |  t q t q t qd S r#   )	r   rJ   r=   r7   r   
_PUSH_LIST_POP_APPEND_EMPTY_TUPLE_APPEND_NEXT_VALUE)re   r   coderh   r   r   rh      s   
z/_Unflattener._build_unflatten_code.<locals>.recr   )r   re   r   rt   r   rm      s   z"_Unflattener._build_unflatten_codec                 C   s   t |}g }|}g }| jD ]3}|tu r"|| |g  |d }q|tu r.||  q|tu r8|d q|tu r@| }q|rGJ ||rMJ ||S )z*Rebuild a nested tuple structure.
        r   )	r   rn   rp   r   rs   popleftrr   rq   pop)r   flatitervalsr(   curstackopr   r   r   rN      s&   



z_Unflattener.unflattenN)r1   r2   r3   r4   r   rm   rN   r   r   r   r   r;      s
    r;   N)collectionsr   
numba.corer   r   objectr   r5   r>   rp   rs   rr   rq   r;   r   r   r   r   <module>   s    5P