
    Ae/                         d dl mZ d dlZ ej                  eeee       ddlmZ ddlmZm	Z	m
Z
  e       Z G d de      Zy)	    )absolute_importN)BOLEOLEOF	NOT_FOUND   )Errors)r   r   r   c                   P    e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 ZddZd Zy)Scannera  
    A Scanner is used to read tokens from a stream of characters
    using the token set specified by a Plex.Lexicon.

    Constructor:

      Scanner(lexicon, stream, name = '')

        See the docstring of the __init__ method for details.

    Methods:

      See the docstrings of the individual methods for more
      information.

      read() --> (value, text)
        Reads the next lexical token from the stream.

      position() --> (name, line, col)
        Returns the position of the last token read using the
        read() method.

      begin(state_name)
        Causes scanner to change state.

      produce(value [, text])
        Causes return of a token value to the caller of the
        Scanner.

    Nc                    d| _         d| _        d| _        d| _        d| _        d| _        d| _        d| _        d| _        d| _	        d| _
        || _        || _        || _        g | _        d| _        | j!                  d       d| _        d| _        d| _        t$        | _        d| _        ||d   |d    c| _        | _        yy)a  
        Scanner(lexicon, stream, name = '')

          |lexicon| is a Plex.Lexicon instance specifying the lexical tokens
          to be recognised.

          |stream| can be a file object or anything which implements a
          compatible read() method.

          |name| is optional, and may be the name of the file being
          scanned or any other identifying string.
        r    r   N   )tracebufferbuf_start_posnext_poscur_poscur_line	start_pos
start_line	start_coltext
state_namelexiconstreamnamequeueinitial_statebegincur_line_startr   cur_charinput_state)selfr   r   r   initial_poss        4lib/python3.12/site-packages/Cython/Plex/Scanners.py__init__zScanner.__init__I   s     
		
!

2"1<Q+a..DM4. #    c                    | j                   }|sn| j                         \  | _        }|"| j                  d       | j	                          n/|j                  | | j                        }|| j                  |       |sn|d   }|d= |S )a"  
        Read the next lexical token from the stream and return a
        tuple (value, text), where |value| is the value associated with
        the token as specified by the Lexicon, and |text| is the actual
        string read from the stream. Returns (None, '') on end of file.
        Nr   )r   scan_a_tokenr   produceeofperform)r#   r   actionvalueresults        r%   readzScanner.readq   s     

 $ 1 1 3DIv~T"
tTYY7$LL'  q!Hr'   c                 ~   | j                   | _        | j                  | _        | j                   | j                  z
  | _        | j                         }|r| j                  r%t        d|| j                  | j                   fz         | j                  | j                  | j                  z
  | j                   | j                  z
   }||fS | j                   | j                  k(  rA| j                  t        u r| j                          | j                  | j                  t        u ryt        j                   | | j"                        )z
        Read the next input sequence recognised by the machine
        and return (text, action). Returns ('', None) on end of
        file.
        z"Scanner: read: Performing %s %d:%dr   N)r   r   r   r   r    r   run_machine_inlinedr   printr   r   r!   r   	next_charr   r	   UnrecognizedInputr   )r#   r-   r   s      r%   r)   zScanner.scan_a_token   s    --(;(;;))+zz:DNNDLL>: : ;;;!3!33t1113D &>!||t~~-==C'NN$==(DMMS,@&**4AAr'   c           	         | j                   }| j                  }| j                  }| j                  }| j                  }| j
                  }| j                  }| j                  }| j                  }	t        |      }
d\  }}}}}}}| j                  }	 |rt        d|d   ||t        |      fz         |d   }||||||||f\  }}}}}}}|}|j                  |t              }|t        u r|xr |j                  d      }|r|rt        d|d   z         |}|dk(  r|}||	z
  }||
k  r||   }|dz  }nn| j                  |	z
  }| j                   j#                  d	      }| j                  |d |z   }|| _        |	|z  }	|	| _        t        |      }
||z  }|r||   }|dz  }nd
}|dk(  r	t$        }d}nd|s	t$        }d}nY|}nV|dk(  rd}d}nL|dk(  r|dz  }|x}}t&        }d}n5|dk(  r	t(        }d}n'd
}n$|rt        d       ||||||||f\  }}}}}}}nd}n|| _        || _        || _        || _        || _        || _        |r|t        d|z         |S )z;
        Inlined version of run_machine for speed.
        )Nr   r   r   r   r   r   r   zState %d, %d/%d:%s -->numberr-   NelsezState %di   r   
r            blockedzDoing %s)r   r   r   r    r!   r"   r   r   r   lenr   r4   reprgetr   r   r   r0   r   r   r   )r#   stater   r   r    r!   r"   r   r   r   buf_lenb_action	b_cur_pos
b_cur_lineb_cur_line_start
b_cur_charb_input_state
b_next_posr   r-   c	new_state	buf_indexdiscarddatas                            r%   r3   zScanner.run_machine_inlined   s    "",,==,,==&&==**f+$ 	a)Z)9:}V`

.(O['4>2K K L 8_F!GX~xV^^ i)Z1A:}^h A		!Y/II%3%))F"3	*y'::;!!#&G (= 8I 7*"9- A"&..="@#{{//7!%WX!6!=&,%0-:*"%f+!W,	 &y 1A$MH #AEz#&&'#&&'#$ A%$H"#K A%MH/77NW"H"#K A%"H"#K"H )$' "9j:J#]J@6VWh{H "FY \  , & !j6)*r'   c                 t   | j                   }| j                  rt        dd|| j                  fz         |dk(  rV| j                  | _        | j                         }|dk(  rt        | _        d| _         n|st        | _        d| _         n|| _        nx|dk(  rd| _        d| _         nd|dk(  r@| xj                  dz  c_        | j                  x| _	        | _        t        | _        d| _         n|dk(  rt        | _        d| _         nd	| _        | j                  r&t        d
|| j                  | j                  fz         y y )NzScanner: next: %s [%d] %dz                    r   r:   r   r;   r<   r=   r   z--> [%d] %d %r)r"   r   r4   r   r   	read_charr   r!   r   r    r   r   )r#   r"   rK   s      r%   r5   zScanner.next_char
  s   &&::-;0UUV!==DL AEz ##$  ##$  !A!DM DAMMQM15>D$,DM DADM DDM::"k4<<%OOP r'   c                 H    | j                   | j                  | j                  fS )am  
        Return a tuple (name, line, col) representing the location of
        the last token read using the read() method. |name| is the
        name that was provided to the Scanner constructor; |line|
        is the line number in the stream (1-based); |col| is the
        position within the line of the first character of the token
        (0-based).
        )r   r   r   r#   s    r%   positionzScanner.position)  s     		4??DNN;;r'   c                 "    | j                         S )zOPython accessible wrapper around position(), only for error reporting.
        )rT   rS   s    r%   get_positionzScanner.get_position4  s     }}r'   c                 R    | j                   j                  |      | _        || _        y)z8Set the current state of the scanner to the named state.N)r   get_initial_stater   r   )r#   r   s     r%   r   zScanner.begin9  s%     LL**:6 	$r'   c                 Z    || j                   }| j                  j                  ||f       y)a  
        Called from an action procedure, causes |value| to be returned
        as the token value from read(). If |text| is supplied, it is
        returned in place of the scanned text.

        produce() can be called more than once during a single call to an action
        procedure, in which case the tokens are queued up and returned one
        at a time by subsequent calls to read(), until the queue is empty,
        whereupon scanning resumes.
        N)r   r   append)r#   r.   r   s      r%   r*   zScanner.produce?  s(     <99D

5$-(r'   c                      y)z_
        Override this method if you want something to be done at
        end of file.
        N rS   s    r%   r+   zScanner.eofN  s    r'   r2   )N)__name__
__module____qualname____doc__r&   r0   r)   r3   r5   rT   rV   r   r*   r+   r\   r'   r%   r   r      s@    b&QP*B4hTQ>	<
%)r'   r   )
__future__r   cythondeclareobjectr   r	   Regexpsr   r   r   r   r   r\   r'   r%   <module>rf      s?    '  6v6V D  " "H	{f {r'   