ó
\K]c           @@ s£   d  d l  m Z m Z d  d l m Z d  d l m Z m Z d e f d „  ƒ  YZ	 d e f d „  ƒ  YZ
 d „  Z d	 Z d
 Z d Z d Z d e f d „  ƒ  YZ d S(   i    (   t   print_functiont   absolute_import(   t   deque(   t   cgutilst   typest
   DataPackerc           B@ s>   e  Z d  Z d „  Z d „  Z d d „ Z d „  Z d „  Z RS(   s¨   
    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         C@ s¬   | |  _  | |  _ g  | D] } | j | ƒ ^ q |  _ g  |  _ g  |  _ x\ t | ƒ D]N \ } } t | t j	 ƒ sV |  j j
 | ƒ |  j j
 |  j | j ƒ  ƒ qV qV Wd  S(   N(   t   _dmmt	   _fe_typest   lookupt   _modelst	   _pack_mapt	   _be_typest	   enumeratet
   isinstanceR   t   Omittedt   appendt   get_data_type(   t   selft   dmmt   fe_typest   tyt   i(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt   __init__   s    		%		c         C@ sC   g  |  j  D]# } |  j | j | | | ƒ ^ q
 } t j | | ƒ S(   sE   
        Return the given values packed as a data structure.
        (   R
   R	   t   as_dataR   t   make_anonymous_struct(   R   t   buildert   valuesR   t   elems(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyR      s    0c   	      C@ sŽ   g  } x t  |  j ƒ D]p \ } } t j | | d | ƒ } |  j | j | | ƒ } | d  k r| | j |  j | | f ƒ q | | | <q W| S(   Ni    (	   R   R
   R   t   gep_inboundsR	   t   load_from_data_pointert   NoneR   R   (	   R   R   t   ptrt   formal_listt   resR   t   i_formalt   elem_ptrt   val(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt   _do_load%   s    c         C@ s   |  j  | | ƒ S(   sK   
        Load the packed values and return a (type, value) tuples.
        (   R%   (   R   R   R   (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt   load0   s    c         C@ s   |  j  | | | ƒ d S(   sƒ   
        Load the packed values into a sequence indexed by formal
        argument number (skipping any Omitted position).
        N(   R%   (   R   R   R   R    (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt	   load_into6   s    N(	   t   __name__t
   __module__t   __doc__R   R   R   R%   R&   R'   (    (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyR   	   s   			t	   ArgPackerc           B@ sM   e  Z d  Z d „  Z d „  Z d „  Z d „  Z d d „ Z e d „  ƒ Z	 RS(   s  
    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.
    alignemnt, 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@ sž   | |  _  | |  _ t | ƒ |  _ g  |  _ g  } xC | D]; } |  j  j | ƒ } |  j j | ƒ | j | j ƒ  ƒ q7 Wt | ƒ |  _	 t
 t | ƒ ƒ |  _ d  S(   N(   R   t   _fe_argst   lent   _nargst   _dm_argsR   R   t   get_argument_typet   _Unflattenert   _unflattenert   listt   _flattent   _be_args(   R   R   t   fe_argst   argtysR   t   dm(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyR   K   s    			c         C@ sŽ   t  | ƒ |  j k r7 t d |  j t  | ƒ f ƒ ‚ n  | sA d Sg  t |  j | ƒ D] \ } } | j | | ƒ ^ qT } t t | ƒ ƒ } | S(   s$   Flatten all argument values
        s+   invalid number of args: expected %d, got %d(    (   R-   R.   t	   TypeErrort   zipR/   t   as_argumentt   tupleR4   (   R   R   R   R8   R$   t   args(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt   as_argumentsY   s    4c         C@ sM   |  j  j | ƒ } g  t |  j | ƒ D] \ } } | j | | ƒ ^ q% } | S(   s&   Unflatten all argument values
        (   R2   t	   unflattenR:   R/   t   from_argument(   R   R   R=   t   valtreeR8   R$   R   (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt   from_argumentsj   s    4c         C@ sF   |  j  j | ƒ } x- t | | ƒ D] \ } } |  j | | ƒ q" Wd S(   s9   Assign names for each flattened argument values.
        N(   R2   R?   R:   t   _assign_names(   R   R=   t   namesRA   t   avalt   aname(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt   assign_namesu   s    c         C@ s•   t  | t t f ƒ rR xy t | ƒ D]) \ } } |  j | | d | | f ƒq" Wn? d j t t | ƒ ƒ } | | g } d j t t	 | ƒ ƒ | _
 d  S(   Nt   deptht   .(   R   R<   R3   R   RC   t   joint   mapt   strt   filtert   boolt   name(   R   t   val_or_nestedRO   RH   t   posRE   t   postfixt   parts(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyRC   }   s    $c         C@ s   t  d „  |  j Dƒ ƒ S(   s\   Return a list of LLVM types that are results of flattening
        composite types.
        c         s@ s!   |  ] } | d k r | Vq d  S(   N(    (    (   t   .0R   (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pys	   <genexpr>‹   s    (   R<   R5   (   R   (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt   argument_types†   s    (    (
   R(   R)   R*   R   R>   RB   RG   RC   t   propertyRU   (    (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyR+   >   s   					c         @ s   ‡  f d †  ‰  ˆ  |  ƒ S(   s3   
    Flatten nested iterable of (tuple, list).
    c         3@ sN   xG |  D]? } t  | t t f ƒ rA x! ˆ  | ƒ D] } | Vq/ Wq | Vq Wd  S(   N(   R   R<   R3   (   t   iterableR   t   j(   t   rec(    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyRY   ’   s
    (    (   RW   (    (   RY   s5   lib/python2.7/site-packages/numba/datamodel/packer.pyR4   Ž   s    i   i   i   i   R1   c           B@ s)   e  Z d  Z d „  Z d „  Z d „  Z RS(   sè   
    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   |  j  | ƒ |  _ d  S(   N(   t   _build_unflatten_codet   _code(   R   t   pattern(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyR   ©   s    c         @ s&   g  ‰  ‡  ‡ f d †  ‰ ˆ | ƒ ˆ  S(   sz   Build the unflatten opcode sequence for the given *iterable* structure
        (an iterable of nested sequences).
        c         @ s€   xy |  D]q } t  | t t f ƒ rk t | ƒ d k r[ ˆ  j t ƒ ˆ | ƒ ˆ  j t ƒ qx ˆ  j t ƒ q ˆ  j t ƒ q Wd  S(   Ni    (	   R   R<   R3   R-   R   t
   _PUSH_LISTt   _POPt   _APPEND_EMPTY_TUPLEt   _APPEND_NEXT_VALUE(   RW   R   (   t   codeRY   (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyRY   ±   s    
(    (   R   RW   (    (   Ra   RY   s5   lib/python2.7/site-packages/numba/datamodel/packer.pyRZ   ¬   s    
c         C@ sè   t  | ƒ } g  } | } g  } x |  j D]’ } | t k ra | j | ƒ | j g  ƒ | d } q( | t k rƒ | j | j ƒ  ƒ q( | t k rŸ | j d ƒ q( | t k r( | j ƒ  } q( q( W| sÑ t	 | ƒ ‚ | sä t	 | ƒ ‚ | S(   s*   Rebuild a nested tuple structure.
        iÿÿÿÿ(    (
   R   R[   R]   R   R`   t   popleftR_   R^   t   popt   AssertionError(   R   t   flatitert   valsR!   t   curt   stackt   op(    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyR?   À   s$    (   R(   R)   R*   R   RZ   R?   (    (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyR1   ¡   s   		N(   t
   __future__R    R   t   collectionsR   t   numbaR   R   t   objectR   R+   R4   R]   R`   R_   R^   R1   (    (    (    s5   lib/python2.7/site-packages/numba/datamodel/packer.pyt   <module>   s   5P	