
    :eq                       d Z ddlmZ ddlZddlZddlZddlZddlm	Z	 ddlm
Z
 ddlmZ ej                  rj ej                  d	      Zej                   d
ej"                  e   f   Zej(                  e   Zej,                  ej                   eej"                  e   f      Z G d d
ej0                        Zd%dZd&dZej8                   G d d             Zej8                   G d de             Zej8                   G d de             Zej8                   G d de             Z ej8                   G d de             Z!ej8                   G d de             Z"ej8                   G d de             Z#d'dZ$d(dZ%ejL                  d)d       Z'e'jP                  d*d       Z)e'jP                  d+d        Z)e'jP                  d,d!       Z)e'jP                  d-d"       Z)e'jP                  d.d#       Z)e'jP                  d/d$       Z)y)0a  Rust CFG parser.

Rust uses its `cfg()` format in cargo.

This may have the following functions:
 - all()
 - any()
 - not()

And additionally is made up of `identifier [ = str]`. Where the str is optional,
so you could have examples like:
```
[target.`cfg(unix)`.dependencies]
[target.'cfg(target_arch = "x86_64")'.dependencies]
[target.'cfg(all(target_arch = "x86_64", target_arch = "x86"))'.dependencies]
```
    )annotationsN   )builder   )mparser)MesonBugException_T	TokenTypec                  >   e Zd Z ej                         Z ej                         Z ej                         Z ej                         Z ej                         Z	 ej                         Z
 ej                         Z ej                         Z ej                         Zy)r
   N)__name__
__module____qualname__enumautoLPARENRPARENSTRING
IDENTIFIERALLANYNOTCOMMAEQUAL     6/usr/lib/python3/dist-packages/mesonbuild/cargo/cfg.pyr
   r
   (   sw    TYY[FTYY[FTYY[FJ
$))+C
$))+C
$))+CDIIKEDIIKEr   c              #    K   g }d}| D ]S  }|j                         s|dv s	|dk(  r|rdj                  |      }|j                          |rt        j                  |f nd|dk(  rt        j
                  df nJ|dk(  rt        j                  df n0|dk(  rt        j                  df n|rt        j                  |f |d	k(  rt        j                  df |d
k(  rt        j                  df |dk(  rt        j                  df |dk(  rt        j                  df '|j                         r9|dk(  r| }C|j                  |       V |r$t        j                  dj                  |      f yyw)ziLex a cfg() expression.

    :param raw: The raw cfg() expression
    :return: An iterable of tokens
    F>   (),=" anyNallnotr   r   r    r!   )isspacejoinclearr
   r   r   r   r   r   r   r   r   r   append)rawbuffer	is_stringsvals        r   lexerr0   5   sm     FI !99;!33SV''&/CLLN ''-- }}d++ }}d++ }}d++ ++S11Cx ''..c ''..c --c --8%IMM!C!D ##RWWV_55 s   FFc              #     K   	 t        |       }	 |}	 t        |       }||f |y# t        $ r Y yw xY w# t        $ r d}Y &w xY ww)zGet the current value of the iterable, and the next if possible.

    :param iter: The iterable to look into
    :yield: A tuple of the current value, and, if possible, the next
    :return: nothing
    N)nextStopIteration)iternext_currents      r   	lookaheadr7   d   sm     T

 	JE un= 	    	E	s@   A( A7 
A	4A4AAAAAc                      e Zd ZdZy)IRzBase IR node for Cargo CFG.N)r   r   r   __doc__r   r   r   r9   r9      s     &r   r9   c                      e Zd ZU ded<   y)StringstrvalueNr   r   r   __annotations__r   r   r   r<   r<      	     Jr   r<   c                      e Zd ZU ded<   y)
Identifierr=   r>   Nr?   r   r   r   rC   rC      rA   r   rC   c                  "    e Zd ZU ded<   ded<   y)Equalr9   lhsrhsNr?   r   r   r   rE   rE      s     
G	Gr   rE   c                      e Zd ZU ded<   y)Any
T.List[IR]argsNr?   r   r   r   rI   rI      
     r   rI   c                      e Zd ZU ded<   y)AllrJ   rK   Nr?   r   r   r   rN   rN      rL   r   rN   c                      e Zd ZU ded<   y)Notr9   r>   Nr?   r   r   r   rP   rP      s	     Ir   rP   c           	        t        |       \  \  }}}||\  }}nd\  }}|t        j                  u r0|t        j                  u rt	        t        |      t        |             S |t        j                  u rt        |      S |t        j                  u rt        |       S |t        j                  t        j                  hv r|t        j                  u rt        nt        }|t        j                  u sJ t        |        g }g }|t        j                  urt        |       \  \  }}}|t        j                  u r=|j!                  t        t#        t%        |                         |j'                          n|j!                  ||f       |t        j                  ur|r,|j!                  t        t#        t%        |                          ||      S |t        j(                  u r|t        |        g }|t        j                  ur7t        |       \  \  }}}|j!                  ||f       |t        j                  ur7t+        t        t#        t%        |                        S t-        d|       )N)NNzUnhandled Cargo token: )r2   r
   r   r   rE   rC   _parser   r<   r   r   rN   rI   r   r   r   r*   r7   r4   r)   r   rP   r   )	asttokenr>   n_streamntoken_type_streamrK   s	            r   rR   rR      s   #CyNUEH	 	 	$$$Y__$E*F3K88	   e}	c{	..	-3)))))S	9+++ $S	NUEA	'F9T&\#:;<uen- 9+++ KKyf678T{	S	9+++ $S	NUEAMM5%.) 9+++ 6)DL1233
5eW=
>>r   c                @    t        t        |             }t        |      S )zParse the tokenized list into Meson AST.

    :param ast: An iterable of Tokens
    :return: An mparser Node to be used as a conditional
    )r7   r4   rR   )rS   ast_is     r   parser\      s     &d3i0E%=r   c                    t         N)NotImplementedErrorirbuilds     r   ir_to_mesonrc      s    
r   c                8    |j                  | j                        S r^   )stringr>   r`   s     r   rW   rW      s    <<!!r   c                   |j                  d      }| j                  dk(  r|j                  d|      S | j                  dv r|j                  d|      S | j                  dk(  r|j                  d|      S t        d| j                         )	Nhost_machinetarget_arch
cpu_family>   	target_ostarget_familysystemtarget_endianendianzUnhandled Cargo identifier: )
identifierr>   methodr   )ra   rb   rg   s      r   rW   rW      s    ##N3L	xx= ||L,77	3	3||Hl33	_	$||Hl33
:288*E
FFr   c                v    |j                  t        | j                  |      t        | j                  |            S r^   )equalrc   rF   rG   r`   s     r   rW   rW      s)    ;;{26651;rvvu3MNNr   c                L    |j                  t        | j                  |            S r^   )not_rc   r>   r`   s     r   rW   rW      s    ::k"((E233r   c                    t        t        | j                              }t        |      }|j	                  t        t        |      |      t        ||            }|D ]  }|j	                  t        ||      |      }  |S r^   )r4   reversedrK   r2   or_rc   ra   rb   rK   lastcuras         r   rW   rW     sk    !"D:D
))KT
E2Ke4L
MC 4iiAu-s34Jr   c                    t        t        | j                              }t        |      }|j	                  t        t        |      |      t        ||            }|D ]  }|j	                  t        ||      |      }  |S r^   )r4   rv   rK   r2   and_rc   rx   s         r   rW   rW     sk    !"D:D
**[dU3[u5M
NC 5jjQ.45Jr   )r+   r=   return_LEX_STREAM)r4   zT.Iterator[_T]r~   z'T.Iterator[T.Tuple[_T, T.Optional[_T]]])rS   _LEX_STREAM_AHr~   r9   )rS   r   r~   r9   )ra   zT.Anyrb   builder.Builderr~   mparser.BaseNode)ra   r<   rb   r   r~   r   )ra   rC   rb   r   r~   r   )ra   rE   rb   r   r~   r   )ra   rP   rb   r   r~   r   )ra   rI   rb   r   r~   r   )ra   rN   rb   r   r~   r   )*r:   
__future__r   dataclassesr   	functoolstypingTr#   r   r   mesonlibr   TYPE_CHECKINGTypeVarr	   TupleOptionalr=   
_LEX_TOKENIterabler   Iteratorr   Enumr
   r0   r7   	dataclassr9   r<   rC   rE   rI   rN   rP   rR   r\   singledispatchrc   registerrW   r   r   r   <module>r      sO  $ #       (??	4Bajjo56J**Z(KZZ
AJJz4J(J KLN
		 
,6^8 & & &
 R  
   
 B   "  
 "  
 "  
)?X   " " G G O O 4 4    r   