a
    bP?                     @   s  d dl mZ d dlZzd dlmZ W n eyB   d dlmZ Y n0 ddlmZ dZ	dZ
d	Zed
Zdd Zdd Zdd Zdd Zdd ZG dd deZdd ZG dd deZG dd deZ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G d%d& d&eZe Zd'e_d(e_ d)d* Z!d+d, Z"d-d. Z#d/d0 Z$e$d1Z%d2e%_d3e%_ dDd4d5Z&d6d7 Z'd8d9 Z(d:d; Z)d<d= Z*ee	Z+d>e+_d?e+_ ee
Z,d@e,_dAe,_ eeZ-dBe-_dCe-_ dS )E    )absolute_importN)maxsize)maxint   )ErrorsZboleoleof
c                 C   s   t | }|  d}t|}g }||k rt|| }|d }|d7 }||k rn|t|| krn|d7 }|d7 }qD|| || q |S )z
    Return a list of character codes consisting of pairs
    [code1a, code1b, code2a, code2b,...] which cover all
    the characters in |s|.
    r   r   )listsortlenordappend)sZ	char_listinresultcode1code2 r   c/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/Cython/Plex/Regexps.pychars_to_ranges"   s    

r   c                 C   sP   t | td}t|tdd }||k rHtdtd }|| || fS dS dS )z
    If the range of characters from code1 to code2-1 includes any
    lower case letters, return the corresponding upper case range.
    azr   ANmaxr   minr   r   Zcode3Zcode4dr   r   r   uppercase_range9   s    r    c                 C   sP   t | td}t|tdd }||k rHtdtd }|| || fS dS dS )z
    If the range of characters from code1 to code2-1 includes any
    upper case letters, return the corresponding lower case range.
    r   Zr   r   Nr   r   r   r   r   lowercase_rangeG   s    r"   c                    s&    fddt dt dD }t| S )z
    Given a list of codes as returned by chars_to_ranges, return
    an RE which will match a character in any of the ranges.
    c                    s"   g | ]}t  |  |d   qS )r   )	CodeRange).0r   	code_listr   r   
<listcomp>Z       zCodeRanges.<locals>.<listcomp>r      )ranger   Alt)r&   re_listr   r%   r   
CodeRangesU   s    r-   c                 C   sB   | t   kr|k r4n ntt| t ttt d |S t| |S dS )z
    CodeRange(code1, code2) is an RE which matches any character
    with a code |c| in the range |code1| <= |c| < |code2|.
    r   N)nl_coder+   RawCodeRange
RawNewliner   r   r   r   r   r#   ^   s    
r#   c                   @   sd   e Zd ZdZdZd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S )REa  RE is the base class for regular expression constructors.
    The following operators are defined on REs:

         re1 + re2         is an RE which matches |re1| followed by |re2|
         re1 | re2         is an RE which matches either |re1| or |re2|
    r   Nc                 C   s   t d| jj dS )aM  
        This method should add states to |machine| to implement this
        RE, starting at |initial_state| and ending at |final_state|.
        If |match_bol| is true, the RE must be able to match at the
        beginning of a line. If nocase is true, upper and lower case
        letters should be treated as equivalent.
        z %s.build_machine not implementedN)NotImplementedError	__class____name__)selfmachineinitial_statefinal_state	match_bolnocaser   r   r   build_machine{   s    	zRE.build_machinec                 C   s"   |  }|| ||| |S )z~
        Given a state |s| of machine |m|, return a new state
        reachable from |s| on character |c| or epsilon.
        )	new_statelink_toadd_transition)r6   mr8   cr   r   r   r   	build_opt   s    
zRE.build_optc                 C   s
   t | |S N)Seqr6   otherr   r   r   __add__   s    z
RE.__add__c                 C   s
   t | |S rC   )r+   rE   r   r   r   __or__   s    z	RE.__or__c                 C   s   | j r| j S |  S d S rC   )strcalc_strr6   r   r   r   __str__   s    z
RE.__str__c                 C   s   t |ts| ||d d S )NzPlex.RE instance)
isinstancer2   
wrong_typer6   numvaluer   r   r   check_re   s    
zRE.check_rec                 C   s"   t |t dkr| ||d d S )N string)typerN   rO   r   r   r   check_string   s    zRE.check_stringc                 C   s8   |  || t|dkr4td|| jjt|f d S )Nr   zOInvalid value for argument %d of Plex.%s.Expected a string of length 1, got: %s)rV   r   r   ZPlexValueErrorr4   r5   reprrO   r   r   r   
check_char   s    zRE.check_charc                 C   sL   t |tjkr$d|jj|jjf }n
t |j}td|| jj||f d S )Nz%s.%s instancez<Invalid type for argument %d of Plex.%s (expected %s, got %s)rU   typesZInstanceTyper4   
__module__r5   r   ZPlexTypeError)r6   rP   rQ   expectedgotr   r   r   rN      s    
zRE.wrong_type)r5   rZ   __qualname____doc__nullablematch_nlrI   r<   rB   rG   rH   rL   rR   rV   rX   rN   r   r   r   r   r2   o   s   
r2   c                 C   s>   t | dkr$tt| t| d }nt| }dt|  |_|S )z;
    Char(c) is an RE which matches the character |c|.
    r   zChar(%s))r   r#   r   SpecialSymbolrW   rI   )rA   r   r   r   r   Char   s
    rb   c                   @   s<   e Zd ZdZdZdZdZdZdZdd Z	dd Z
dd	 ZdS )
r/   z
    RawCodeRange(code1, code2) is a low-level RE which matches any character
    with a code |c| in the range |code1| <= |c| < |code2|, where the range
    does not include newline. For internal use only.
    r   Nc                 C   s&   ||f| _ t||| _t||| _d S rC   )r*   r    r"   )r6   r   r   r   r   r   __init__   s    
zRawCodeRange.__init__c                 C   sP   |r|  ||t}|| j| |rL| jr8|| j| | jrL|| j| d S rC   )rB   BOLr?   r*   r    r"   r6   r@   r8   r9   r:   r;   r   r   r   r<      s    zRawCodeRange.build_machinec                 C   s   d| j | jf S )NzCodeRange(%d,%d)r1   rK   r   r   r   rJ     s    zRawCodeRange.calc_str)r5   rZ   r]   r^   r_   r`   r*   r    r"   rc   r<   rJ   r   r   r   r   r/      s   
r/   c                   @   s    e Zd ZdZdZdZdd ZdS )_RawNewlinezd
    RawNewline is a low-level RE which matches a newline character.
    For internal use only.
    r   r   c                 C   s8   |r|  ||t}|  ||t}|ttd f| d S Nr   )rB   rd   EOLr?   r.   )r6   r@   r8   r9   r:   r;   r   r   r   r   r<     s    z_RawNewline.build_machineN)r5   rZ   r]   r^   r_   r`   r<   r   r   r   r   rf     s   rf   c                   @   s,   e Zd ZdZdZdZdZdd Zdd ZdS )ra   zx
    SpecialSymbol(sym) is an RE which matches the special input
    symbol |sym|, which is one of BOL, EOL or EOF.
    r   Nc                 C   s
   || _ d S rC   )sym)r6   ri   r   r   r   rc   #  s    zSpecialSymbol.__init__c                 C   s.   |r| j tkr| ||t}|| j | d S rC   )ri   rh   rB   rd   r?   re   r   r   r   r<   &  s    zSpecialSymbol.build_machine)	r5   rZ   r]   r^   r_   r`   ri   rc   r<   r   r   r   r   ra     s   ra   c                   @   s(   e Zd ZdZdd Zdd Zdd ZdS )	rD   z]Seq(re1, re2, re3...) is an RE which matches |re1| followed by
    |re2| followed by |re3|...c                 G   sx   d}t |D ]\}}| || |o(|j}q|| _|| _t|}d}|rn|d8 }|| }|jrdd}qn|jsDqnqD|| _d S )Nr   r   )	enumeraterR   r_   r,   r   r`   )r6   r,   r_   r   rer`   r   r   r   rc   2  s"    zSeq.__init__c                 C   s   | j }t|dkr|| n^|}t|}t|D ]H\}	}
|	|d k rP| }n|}|
||||| |}|
jpx|ox|
j}q2d S Nr   r   )r,   r   r>   rj   r=   r<   r`   r_   )r6   r@   r8   r9   r:   r;   r,   s1r   r   rk   s2r   r   r   r<   E  s    
zSeq.build_machinec                 C   s   dd tt| j S )NzSeq(%s),joinmaprI   r,   rK   r   r   r   rJ   U  s    zSeq.calc_strNr5   rZ   r]   r^   rc   r<   rJ   r   r   r   r   rD   .  s   rD   c                   @   s(   e Zd ZdZdd Zdd Zdd ZdS )	r+   zRAlt(re1, re2, re3...) is an RE which matches either |re1| or
    |re2| or |re3|...c                 G   s~   || _ d}d}g }g }d}|D ]B}| || |jrD|| d}n
|| |jrXd}|d7 }q|| _|| _|| _|| _d S rl   )r,   rR   r_   r   r`   nullable_resnon_nullable_res)r6   r,   r_   r`   rt   ru   r   rk   r   r   r   rc   ]  s&    


zAlt.__init__c                 C   sX   | j D ]}|||||| q| jrT|r6| ||t}| jD ]}||||d| q<d S )Nr   )rt   r<   ru   rB   rd   )r6   r@   r8   r9   r:   r;   rk   r   r   r   r<   s  s    

zAlt.build_machinec                 C   s   dd tt| j S )NzAlt(%s)ro   rp   rK   r   r   r   rJ   |  s    zAlt.calc_strNrs   r   r   r   r   r+   Y  s   	r+   c                   @   s(   e Zd ZdZdd Zdd Zdd ZdS )	Rep1z@Rep1(re) is an RE which matches one or more repetitions of |re|.c                 C   s&   |  d| || _|j| _|j| _d S rg   )rR   rk   r_   r`   )r6   rk   r   r   r   rc     s    zRep1.__init__c                 C   sN   |  }|  }|| | j||||p0| jj| || || d S rC   )r=   r>   rk   r<   r`   )r6   r@   r8   r9   r:   r;   rm   rn   r   r   r   r<     s    

zRep1.build_machinec                 C   s
   d| j  S )NzRep1(%s)rk   rK   r   r   r   rJ     s    zRep1.calc_strNrs   r   r   r   r   rv     s   rv   c                   @   s0   e Zd ZdZdZdZdd Zdd Zdd ZdS )	
SwitchCasez
    SwitchCase(re, nocase) is an RE which matches the same strings as RE,
    but treating upper and lower case letters according to |nocase|. If
    |nocase| is true, case is ignored, otherwise it is not.
    Nc                 C   s    || _ || _|j| _|j| _d S rC   )rk   r;   r_   r`   )r6   rk   r;   r   r   r   rc     s    zSwitchCase.__init__c                 C   s   | j ||||| j d S rC   )rk   r<   r;   re   r   r   r   r<     s    zSwitchCase.build_machinec                 C   s   | j rd}nd}d|| jf S )NNoCaseCasez%s(%s))r;   rk   )r6   namer   r   r   rJ     s    zSwitchCase.calc_str)	r5   rZ   r]   r^   rk   r;   rc   r<   rJ   r   r   r   r   rx     s   rx   z8
    Empty is an RE which matches the empty string.
    Emptyc                 C   s$   t ttt|  }dt|  |_|S )z@
    Str1(s) is an RE which matches the literal string |s|.
    Str(%s))rD   tuplerr   rb   rW   rI   r   r   r   r   r   Str1  s    r   c                  G   sH   t | dkrt| d S tttt|  }ddtt|  |_|S dS )z
    Str(s) is an RE which matches the literal string |s|.
    Str(s1, s2, s3, ...) is an RE which matches any of |s1| or |s2| or |s3|...
    r   r   r}   ro   N)r   r   r+   r~   rr   rq   rW   rI   )strsr   r   r   r   Str  s
    r   c                 C   s   t t| }dt|  |_|S )zH
    Any(s) is an RE which matches any character in the string |s|.
    zAny(%s))r-   r   rW   rI   r   r   r   r   Any  s    r   c                 C   s:   t | }|dt  |t t|}dt|  |_|S )zp
    AnyBut(s) is an RE which matches any character (including
    newline) which is not in the string |s|.
    r   z
AnyBut(%s))r   insertr   r   r-   rW   rI   )r   rangesr   r   r   r   AnyBut  s    
r   rS   zT
    AnyChar is an RE which matches any single character (including a newline).
    AnyCharc              	   C   s   |r*t t| t|d }d| |f |_nXg }tdt| dD ],}|t t| | t| |d  d  q>t| }dt|  |_|S )a  
    Range(c1, c2) is an RE which matches any single character in the range
    |c1| to |c2| inclusive.
    Range(s) where |s| is a string of even length is an RE which matches
    any single character in the ranges |s[0]| to |s[1]|, |s[2]| to |s[3]|,...
    r   zRange(%s,%s)r   r)   z	Range(%s))r#   r   rI   r*   r   r   r+   rW   )rm   rn   r   r   r   r   r   r   Range  s    *r   c                 C   s   t | t}d|  |_|S )zI
    Opt(re) is an RE which matches either |re| or the empty string.
    zOpt(%s))r+   r|   rI   rk   r   r   r   r   Opt  s    

r   c                 C   s   t t| }d|  |_|S )zJ
    Rep(re) is an RE which matches zero or more repetitions of |re|.
    zRep(%s))r   rv   rI   r   r   r   r   Rep  s    
r   c                 C   s   t | ddS )z
    NoCase(re) is an RE which matches the same strings as RE, but treating
    upper and lower case letters as equivalent.
    r   r;   rx   rw   r   r   r   ry     s    ry   c                 C   s   t | ddS )z
    Case(re) is an RE which matches the same strings as RE, but treating
    upper and lower case letters as distinct, i.e. it cancels the effect
    of any enclosing NoCase().
    r   r   r   rw   r   r   r   rz      s    rz   z=
    Bol is an RE which matches the beginning of a line.
    Bolz7
    Eol is an RE which matches the end of a line.
    Eolz9
    Eof is an RE which matches the end of the file.
    Eof)N).
__future__r   rY   sysr   r   ImportErrorrS   r   rd   rh   EOFr   r.   r   r    r"   r-   r#   objectr2   rb   r/   rf   r0   ra   rD   r+   rv   rx   r|   r^   rI   r   r   r   r   r   r   r   r   ry   rz   r   r   r   r   r   r   r   <module>	   sl   	n+'!	

		