
    xKg$                     J   d Z ddlmZ ddlmZ ddlmZmZmZm	Z	 ddl
mZmZmZmZmZmZmZmZ d Zd Zd Zd	 Zd
 Zd Zd Z ee ej6                  ej8                              d        Z eej<                  d      d        Z eej<                  d      d        Z  eej<                  d      d        Z! edej<                  ejD                        d        Z#d Z$ eej<                        d        Z% eejL                  jN                  ej<                        d        Z(y)z2
Implement slices and various slice computations.
    )zip_longest)ir)cgutilstypestypingutils)impl_ret_borrowedimpl_ret_new_refimpl_ret_untrackediternext_impllower_builtin
lower_castlower_constantlower_getattrc                     | j                  d|t        j                  |j                  d            }| j	                  ||      }| j                  |||      S )z^
    Fix negative index by adding *size* to it.  Positive
    indices are left untouched.
    <r   )icmp_signedr   Constanttypeaddselect)builderidxsizeis_negativewrapped_indexs        Y/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/numba/cpython/slicing.py	fix_indexr      sJ    
 %%c3DIIq0IJKKKT*M>>+}c::    c                    	 t        j                  j                  d      	t        j                  j                  d      } 	fd} j                  t	        j
                   j                              5 \  }}|5   |d	        |d	       ddd       |5  |} j                  |      } |d||        |d||       ddd       ddd       y# 1 sw Y   ExY w# 1 sw Y   xY w# 1 sw Y   yxY w)z
    Fix *slice* start and stop to be valid (inclusive and exclusive, resp)
    indexing bounds for a sequence of the given *size*.
    r   c                 r   t        |       }t        |      }t        | |       j                  d|	      }j	                  |d      5  t        | |       d d d        j                  d|      }j	                  |d      5  t        | |       d d d        y # 1 sw Y   FxY w# 1 sw Y   y xY w)Nr   Flikely>=)getattrr   setattrr   if_then)

bound_name
lower_repl
upper_replbound	underflowoverflowr   r   slicezeros
         r   	fix_boundzfix_slice.<locals>.fix_bound"   s    z*'5$/z5)''UD9	__Yu_5E:z2 6 &&tUD9__Xe_4E:z2 54	 65 54s   B!
B-!B*-B6startstopN)r   r   r   if_elser   
is_neg_intstepr   )
r   r/   r   	minus_oner1   if_neg_stepif_pos_steplowerupperr0   s
   ```      @r   	fix_slicer<      s     ;;tyy!$DDIIr*I3 
++GUZZ@	AE_kS^gtT*fdD)  EKKi0Egue,feU+  
B	A[ [ 
B	As<   <C3C
C3!)C'
C3C$	 C3'C0	,C33C<c           	      \   |j                   }|j                  }|j                  }t        j                  |j
                  d      }t        j                  |j
                  d      }t        j                  | |      }| j                  ||      }| j                  ||      }	| j                  ||      }
| j                  ||
|	      }| j                  || j                  ||            }| j                  || j                  d||      | j                  d||            }| j                  |||      S )a   
    Given a slice, compute the number of indices it spans, i.e. the
    number of iterations that for_range_slice() will execute.

    Pseudo-code:
        assert step != 0
        if step > 0:
            if stop <= start:
                return 0
            else:
                return (stop - start - 1) // step + 1
        else:
            if stop >= start:
                return 0
            else:
                return (stop - start + 1) // step + 1

    (see PySlice_GetIndicesEx() in CPython)
       r   r%   z<=)r2   r3   r6   r   r   r   r   r5   subr   r   sdivr   )r   slicestructr2   r3   r6   oner0   is_step_negativedeltapos_dividendneg_dividenddividendnominal_lengthis_zero_lengths                 r   get_slice_lengthrJ   =   s   ( EDD
++ejj!
$C;;uzz1%D))'48KKe$E ;;uc*L;;uc*L/|LH[[gll8T&BCN ^^$4$+$7$7eT$J$+$7$7eT$JLN
 >>.$??r   c                 D   |j                   }|j                  }|j                  d      }|j                  d      }| j                  d|j                  |      }| j                  || j                  ||      |      }| j                  || j                  ||      |      }||fS )z?
    Return the [lower, upper) indexing bounds of a slice.
    r   r>   r   )r2   r3   r   r   r6   r   r   )	r   rA   r2   r3   r0   rB   rC   r:   r;   s	            r   get_slice_boundsrL   i   s     ED::a=D
**Q-C **30@0@$GNN+";;tS15:ENN+";;uc2D:E%<r   c                 :    | j                  |j                  |      S )z4
    Fix the given stride for the slice's step.
    )mulr6   )r   r/   strides      r   
fix_striderP   {   s     ;;uzz6**r   c                 n    |j                   r)t        j                  | ||j                  t        df       yy)zP
    Guard against *slicestruct* having a zero step (and raise ValueError).
    slice step cannot be zeroN)has_stepr   
guard_nullr6   
ValueError)contextr   typrA   s       r   guard_invalid_slicerX      s4     ||7G[-=-=&(CD	F r   c                 B    d| j                   dz
  z  dz
  }d||| dz
  dfS )z
    Get the default values for a slice's members:
    (start for positive step, start for negative step,
     stop for positive step, stop for negative step, step)
    r>   r   )address_size)rV   maxints     r   get_defaultsr\      s5     G((1,-2Fvvx!|Q//r   c                 <   t        |       D cg c]"  }| j                  t        j                  |      $ c}\  }}}}}	d gdz  t	        |      dk(  r(|j
                  d   t        j                  ur	|d   d<   nBt        t        |j
                  |            D ]   \  }
\  }}|t        j                  us||
<   " fd} |d|	      }|j                  d|| j                  t        j                  d            }|j                  |||      }|j                  |||      } |d|      } |d|      }|j                  }| j                  ||j                        }||_        ||_        ||_        |j!                         }t#        | ||j                  |      S c c}w )N   r>   r   c                     |    }||S |S N )idefaultval
slice_argss      r   get_arg_valuez-slice_constructor_impl.<locals>.get_arg_value   s    m;NJr      r   )r\   get_constantr   intplenargsnone	enumeratezipr   r   return_typemake_helperr2   r3   r6   	_getvaluer   )rV   r   sigrk   xdefault_start_posdefault_start_negdefault_stop_posdefault_stop_negdefault_steprb   tyrd   rf   r6   rC   default_stopdefault_startr3   r2   sliresre   s                         @r   slice_constructor_implr~      s    7C76KL6K		ejj!	,6KL !J 4yA~#((1+UZZ7Q
1%c#((D&9:LAyC# #
1 ;
 L)D**3+2+?+?

A+NP>>"2"24DFLNN#3#46GIML)D!]+E	B


gs
7CCICHCH
--/CgwEEK 	Ms   'Fr2   c                 @    | j                  |||      }|j                  S r`   )rp   r2   rV   r   rW   valuer|   s        r   slice_start_implr      s     


gsE
2C99r   r3   c                 @    | j                  |||      }|j                  S r`   )rp   r3   r   s        r   slice_stop_implr      s    


gsE
2C88Or   r6   c                     |j                   r| j                  |||      }|j                  S | j                  t        j
                  d      S )Nr>   )rS   rp   r6   rh   r   ri   r   s        r   slice_step_implr      s=    
||!!'36xx##EJJ22r   zslice.indicesc                 p   |d   }| j                  ||j                  d   |d         }|j                  t        j                  ||      d      5  | j
                  j                  |t        d       d d d        |j                  t        j                  ||j                        d      5  | j
                  j                  |t        d       d d d        t        |||       | j                  ||j                  |j                  |j                  |j                  f      S # 1 sw Y   xY w# 1 sw Y   `xY w)Nr>   r   Fr#   )zlength should not be negative)rR   )rp   rk   r(   r   r5   	call_convreturn_user_excrU   is_scalar_zeror6   r<   
make_tuplero   r2   r3   )rV   r   rr   rk   lengthr|   s         r   slice_indicesr      s   !WF


gsxx{DG
<C	++GV<U	K))Z.	
 
L
 
//B5	Q))Z*	
 
R gsF#	CHHchh'  
L	K
 
R	Qs   "D +"D, D),D5c                    | j                  ||      }| j                  t        j                        }t	        |       D cg c]"  }| j                  t        j                  |      $ c}\  }}}	}
}|j                  }|d}|}n|dk  } ||      }|j                  }||r|}n|}n ||      }|j                  }||r|
}n|	}n ||      }||_        ||_        ||_        |j                         S c c}w )NFr   )
rp   get_value_typer   ri   r\   rh   r6   r2   r3   rq   )rV   r   ry   pyvalr|   ltyrs   rt   ru   rv   rw   rx   r6   step_is_negr2   r3   s                   r   make_slice_from_constantr      s   


gr
*C

 
 
,C 7C76KL6K		ejj!	,6KL ::D|Qh4yKKE}%E%EE
::D|#D#D4yCICHCH==?A 	Ms   'C0c                 p    t        |t        j                        r|j                  }n|}t	        | |||      S r`   )
isinstancer   Literalliteral_typer   )rV   r   ry   r   rW   s        r   constant_slicer      s/    "emm$oo#GWc5AAr   c                 2    t        | |||j                        S r`   )r   literal_value)rV   r   fromtytotyrd   s        r   cast_from_literalr   *  s    #$ 4 4 r   N))__doc__	itertoolsr   llvmliter   
numba.corer   r   r   r   numba.core.imputilsr	   r
   r   r   r   r   r   r   r   r<   rJ   rL   rP   rX   r\   r/   VarArgAnyr~   	SliceTyper   r   r   Integerr   r   r   miscSliceLiteralr   ra   r   r   <module>r      sL   "  4 40 0 0;!,H)@X$+F0 ulell599-.,F /,F^ u( ) u' ( u'3 (3 ? @0*Z  B !B EJJ##U__5 6r   