
    ۏDj/                     ~    d 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      Zy)	z3
Python Lexical Analyser

Scanning an input stream
    N)BOLEOLEOF	NOT_FOUND   )Errors)r   r   r   c                       e Zd ZdZddZd Zd Zd Zd Ze	j                  d        Zd	efd
Zd Zd ZddZd Ze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   )r   r   r   N   )tracebufferbuf_start_posnext_poscur_poscur_line	start_poscurrent_scanner_position_tuplelast_token_position_tupletext
state_namelexiconstreamnamequeueinitial_statebegincur_line_startr   cur_charinput_state)selfr   r   r   initial_poss        XC:\Crop_Prediction\Backend\crop-ai-system\venv\Lib\site-packages\Cython/Plex/Scanners.py__init__zScanner.__init__J   s     
.8+)3&		
!

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performr   )r"   r   actionvalueresults        r$   readzScanner.readr   s     

 $ 1 1 3DIv~T"
tTYY7$LL'  27q..!Hr&   c                 D    | j                   j                  d||f|f       y )Nr   )r   insert)r"   tokenr-   positions       r$   unreadzScanner.unread   s    

!uenh78r&   c                     | j                   S N)r   r"   s    r$   get_current_scan_poszScanner.get_current_scan_pos   s    222r&   c                 F   | j                   | _        | j                  | j                  | j                   | j                  z
  f| _        | j                         }|r| j                  r%t        d|| j                  | j                   fz         | j                  | j                  | j                  z
  | j                   | j                  z
   }||fS | j                   | j                  k(  r| 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   r   UnrecognizedInputr   )r"   r,   r   s      r$   r(   zScanner.scan_a_token   s     IIt}}dllT5H5H&H/
+ ))+zz:DNNDLL>: : ;;;!3!33t1113D &>!||t~~-==(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   r<   reprgetr   r   r   r/   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$   r;   zScanner.run_machine_inlined   s   
 ((%)\\&*mm,0,?,?==#'#3#3&*mmkk+/+=+=%([
 $ 	a)Z)9:}V` "ZZ.(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Dy#&&'#&&'#$ A%#H"#K A%MH/77NW"H"#K A%"H"#K!H )$' "9j:J#]J@6VWh{H "F[ `  , & !j6)*r&   returnc                     | j                   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   r7   s    r$   r3   zScanner.position  s     ---r&   c                 "    | j                         S )zX
        Python accessible wrapper around position(), only for error reporting.
        )r3   r7   s    r$   get_positionzScanner.get_position$  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.begin*  s%     LL**:6 	$r&   c                 r    || j                   }| j                  j                  ||f| 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   appendr   )r"   r-   r   s      r$   r)   zScanner.produce0  s3     <99D

E4=$*M*MNOr&   c                      y)z_
        Override this method if you want something to be done at
        end of file.
        N r7   s    r$   r*   zScanner.eof?  s    
 	r&   c                      | j                   d   S )Nr   rY   r7   s    r$   
start_linezScanner.start_lineF  s    --a00r&   r:   r6   )__name__
__module____qualname____doc__r%   r/   r4   r8   r(   cythonfinalr;   tupler3   r[   r   r)   r*   propertyrc   ra   r&   r$   r
   r
      st    p&QP*93B2 \\o ob	.% 	.%P 1 1r&   r
   )rg   rh   declareobjectr   r   Regexpsr   r   r   r   r
   ra   r&   r$   <module>ro      s?     6v6V D  " "H	w1 w1r&   