|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /proc/self/root/usr/lib/python2.7/site-packages/ |
Upload File : |
�
��eGc @ s d Z d e f d � � YZ d d d � � YZ d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d
� Z e d k ry� e j � Z e j d e j � d e � d d d � Z e j d d d d d e d d �e j � \ Z Z e j rGe j � GHn e � e j ree j � GHn e j rud Gn e j r�e j � e d GHn e j d � Wqe k
r�Z e � qe! k
r�Z e � qe k
rZ d GHe" e � GHe j# � e j$ d � qXn d S(! s� This module implements a Finite State Machine (FSM). In addition to state
this FSM also maintains a user defined "memory". So this FSM can be used as a
Push-down Automata (PDA) since a PDA is a FSM + memory.
The following describes how the FSM works, but you will probably also need to
see the example function to understand how the FSM is used in practice.
You define an FSM by building tables of transitions. For a given input symbol
the process() method uses these tables to decide what action to call and what
the next state will be. The FSM has a table of transitions that associate:
(input_symbol, current_state) --> (action, next_state)
Where "action" is a function you define. The symbols and states can be any
objects. You use the add_transition() and add_transition_list() methods to add
to the transition table. The FSM also has a table of transitions that
associate:
(current_state) --> (action, next_state)
You use the add_transition_any() method to add to this transition table. The
FSM also has one default transition that is not associated with any specific
input_symbol or state. You use the set_default_transition() method to set the
default transition.
When an action function is called it is passed a reference to the FSM. The
action function may then access attributes of the FSM such as input_symbol,
current_state, or "memory". The "memory" attribute can be any object that you
want to pass along to the action functions. It is not used by the FSM itself.
For parsing you would typically pass a list to be used as a stack.
The processing sequence is as follows. The process() method is given an
input_symbol to process. The FSM will search the table of transitions that
associate:
(input_symbol, current_state) --> (action, next_state)
If the pair (input_symbol, current_state) is found then process() will call the
associated action function and then set the current state to the next_state.
If the FSM cannot find a match for (input_symbol, current_state) it will then
search the table of transitions that associate:
(current_state) --> (action, next_state)
If the current_state is found then the process() method will call the
associated action function and then set the current state to the next_state.
Notice that this table lacks an input_symbol. It lets you define transitions
for a current_state and ANY input_symbol. Hence, it is called the "any" table.
Remember, it is always checked after first searching the table for a specific
(input_symbol, current_state).
For the case where the FSM did not match either of the previous two cases the
FSM will try to use the default transition. If the default transition is
defined then the process() method will call the associated action function and
then set the current state to the next_state. This lets you define a default
transition as a catch-all case. You can think of it as an exception handler.
There can be only one default transition.
Finally, if none of the previous cases are defined for an input_symbol and
current_state then the FSM will raise an exception. This may be desirable, but
you can always prevent this just by defining a default transition.
Noah Spurrier 20020822
t ExceptionFSMc B s e Z d Z d � Z d � Z RS( s This is the FSM Exception class.c C s
| | _ d S( N( t value( t selfR ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt __init__I s c C s | j
S( N( R ( R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt __str__L s ( t __name__t
__module__t __doc__R R ( ( ( s' /usr/lib/python2.7/site-packages/FSM.pyR E s t FSMc B st e Z d Z d
d � Z d � Z d
d
d � Z d
d
d � Z d
d
d � Z d � Z d � Z
d � Z d � Z RS( s* This is a Finite State Machine (FSM).
c C sX i | _ i | _ d | _ d | _ | | _ | j | _ d | _ d | _ | | _ d S( s This creates the FSM. You set the initial state here. The "memory"
attribute is any object that you want to pass along to the action
functions. It is not used by the FSM. For parsing you would typically
pass a list to be used as a stack. N(
t state_transitionst state_transitions_anyt Nonet default_transitiont input_symbolt
initial_statet
current_statet
next_statet actiont memory( R R R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyR T s c C s | j | _ d | _ d S( s� This sets the current_state to the initial_state and sets
input_symbol to None. The initial state was set by the constructor
__init__(). N( R R R R
( R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt reseth s c C s2 | d k r | } n | | f | j | | f <d S( s� This adds a transition that associates:
(input_symbol, current_state) --> (action, next_state)
The action may be set to None in which case the process() method will
ignore the action and only set the next_state. The next_state may be
set to None in which case the current state will be unchanged.
You can also set transitions for a list of symbols by using
add_transition_list(). N( R R ( R R
t stateR R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt add_transitionq s
c C s@ | d k r | } n x$ | D] } | j | | | | � q Wd S( s� This adds the same transition for a list of input symbols.
You can pass a list or a string. Note that it is handy to use
string.digits, string.whitespace, string.letters, etc. to add
transitions that match character classes.
The action may be set to None in which case the process() method will
ignore the action and only set the next_state. The next_state may be
set to None in which case the current state will be unchanged. N( R R ( R t list_input_symbolsR R R R
( ( s' /usr/lib/python2.7/site-packages/FSM.pyt add_transition_list� s
c C s, | d k r | } n | | f | j | <d S( s This adds a transition that associates:
(current_state) --> (action, next_state)
That is, any input symbol will match the current state.
The process() method checks the "any" state associations after it first
checks for an exact match of (input_symbol, current_state).
The action may be set to None in which case the process() method will
ignore the action and only set the next_state. The next_state may be
set to None in which case the current state will be unchanged. N( R R
( R R R R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt add_transition_any� s c C s | | f | _ d S( s� This sets the default transition. This defines an action and
next_state if the FSM cannot find the input symbol and the current
state in the transition list and if the FSM cannot find the
current_state in the transition_any list. This is useful as a final
fall-through state for catching errors and undefined states.
The default transition can be removed by setting the attribute
default_transition to None. N( R ( R R R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt set_default_transition� s c C s� | j j | | f � r) | j | | f S| j j | � rF | j | S| j d k r\ | j St d t | � t | � f � � d S( sn This returns (action, next state) given an input_symbol and state.
This does not modify the FSM state, so calling this method has no side
effects. Normally you do not call this method directly. It is called by
process().
The sequence of steps to check for a defined transition goes from the
most specific to the least specific.
1. Check state_transitions[] that match exactly the tuple,
(input_symbol, state)
2. Check state_transitions_any[] that match (state)
In other words, match a specific state and ANY input_symbol.
3. Check if the default_transition is defined.
This catches any input_symbol and any state.
This is a handler for errors, undefined states, or defaults.
4. No transition was defined. If we get here then raise an exception.
s" Transition is undefined: (%s, %s).N( R t has_keyR
R R R t str( R R
R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt get_transition� s c C se | | _ | j | j | j � \ | _ | _ | j d k rL | j | � n | j | _ d | _ d S( s� This is the main method that you call to process input. This may
cause the FSM to change state and call an action. This method calls
get_transition() to find the action and next_state associated with the
input_symbol and current_state. If the action is None then the action
is not called and only the current state is changed. This method
processes one complete input symbol. You can process a list of symbols
(or a string) by calling process_list(). N( R
R R R R R ( R R
( ( s' /usr/lib/python2.7/site-packages/FSM.pyt process� s
$ c C s" x | D] } | j | � q Wd S( sp This takes a list and sends each element to process(). The list may
be a string or any iterable object. N( R ( R t
input_symbolst s( ( s' /usr/lib/python2.7/site-packages/FSM.pyt process_list� s
N(
R R R R R R R R R R R R R ( ( ( s' /usr/lib/python2.7/site-packages/FSM.pyR O s
! i����Nc C s | j j | j � d S( N( R t appendR
( t fsm( ( s' /usr/lib/python2.7/site-packages/FSM.pyt BeginBuildNumber s c C s0 | j j � } | | j } | j j | � d S( N( R t popR
R! ( R" R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt BuildNumber s
c C s) | j j � } | j j t | � � d S( N( R R$ R! t int( R" R ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt EndBuildNumber s c C s� | j j � } | j j � } | j d k rD | j j | | � nr | j d k rj | j j | | � nL | j d k r� | j j | | � n& | j d k r� | j j | | � n d S( Nt +t -t *t /( R R$ R
R! ( R" t art al( ( s' /usr/lib/python2.7/site-packages/FSM.pyt
DoOperator s c C s t | j j � � GHd S( N( R R R$ ( R" ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt DoEqual s c C s d GHt | j � GHd S( Ns That does not compute.( R R
( R" ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt Error s c C s� t d g � } | j t d � | j d d d � | j d d t d � | j t j d t
d � | j t j d t d � | j t j d t
d � | j d d t d � Hd GHd GHd GHd GHd GHt d
� } | j | � d S( s� This is where the example starts and the FSM state transitions are
defined. Note that states are strings (such as 'INIT'). This is not
necessary, but it makes the example easier to read. t INITt =t BUILDING_NUMBERs +-*/s Enter an RPN Expression.s. Numbers may be integers. Operators are * / + -s4 Use the = sign to evaluate and print the expression.s
For example: s 167 3 2 2 * * * 1 - =s > N( R R R0 R R R R/ R t stringt digitsR# R% t
whitespaceR' R. t raw_inputR ( t ft inputstr( ( s' /usr/lib/python2.7/site-packages/FSM.pyt main s t __main__t formattert usageR t versions+ $Id: FSM.py 490 2007-12-07 15:46:24Z noah $s -vs --verboseR t
store_truet defaultt helps verbose outputs TOTAL TIME IN MINUTES:g N@i s ERROR, UNEXPECTED EXCEPTIONi ( (% R t ExceptionR R t syst ost tracebackt optparset timeR4 R# R% R' R. R/ R0 R: R t
start_timet OptionParsert TitledHelpFormattert globalst parsert
add_optiont Falset
parse_argst optionst argst verboset asctimet exitt KeyboardInterruptt et
SystemExitR t print_exct _exit( ( ( s' /usr/lib/python2.7/site-packages/FSM.pyt <module>C sF
�H +"