def snap_expression(stream, PatternDict):
"""expression: term
term | expression
"""
__debug_entry("expression", stream)
# -- term
result = snap_term(stream, PatternDict)
if result is None:
return __debug_exit(None, stream)
# -- optional '|'
if not check(stream, '|'):
return __debug_exit(result, stream)
position_1 = stream.tell()
__debug_print("'|' (in expression)")
# -- expression
result_2 = snap_expression(stream, PatternDict)
__debug_print("expression(in expression):", result_2)
if result_2 is None:
stream.seek(position_1)
return __debug_exit(result, stream)
result = parallelize.do([result, result_2],
CloneF=True) # CloneF = False (shold be!)
return __debug_exit(beautifier.do(result), stream)
def snap_expression(stream, PatternDict):
"""expression: term
term | expression
"""
__debug_entry("expression", stream)
# -- term
result = snap_term(stream, PatternDict)
if result is None:
return __debug_exit(None, stream)
# -- optional '|'
if not check(stream, '|'):
return __debug_exit(result, stream)
position_1 = stream.tell()
__debug_print("'|' (in expression)")
# -- expression
result_2 = snap_expression(stream, PatternDict)
__debug_print("expression(in expression):", result_2)
if result_2 is None:
stream.seek(position_1)
return __debug_exit(result, stream)
result = parallelize.do([result, result_2], CloneF=True) # CloneF = False (shold be!)
return __debug_exit(beautifier.do(result), stream)
def do(SM_List):
"""The 'parallelize' module does a union of multiple state machines,
even if they have different origins and need to be combined carefully.
There is no reason, why another 'union' operation should be implemented
in this case.
"""
result = parallelize.do(SM_List)
return beautifier.do(result)
def get_combined_state_machine(StateMachine_List,
FilterDominatedOriginsF=True,
MarkNotSet=set()):
"""Creates a DFA state machine that incorporates the paralell
process of all pattern passed as state machines in
the StateMachine_List. Each origins of each state machine
are kept in the final state, if it is not dominated.
Performs: -- parallelization
-- translation from NFA to DFA
-- Frank Schaefers Adapted Hopcroft optimization.
Again: The state machine ids of the original state machines
are traced through the whole process.
FilterDominatedOriginsF, if set to False, can disable the filtering
of dominated origins. This is important for pre-contexts, because,
all successful patterns need to be reported!
"""
if len(StateMachine_List) == 0:
return None
def __check(Place, sm):
__check_on_orphan_states(Place, sm)
__check_on_init_state_not_acceptance(Place, sm)
def __check_on_orphan_states(Place, sm):
orphan_state_list = sm.get_orphaned_state_index_list()
if len(orphan_state_list) == 0: return
error_msg("After '%s'" % Place + "\n" + \
"Orphaned state(s) detected in regular expression (optimization lack).\n" + \
"Please, log a defect at the projects website quex.sourceforge.net.\n" + \
"Orphan state(s) = " + repr(orphan_state_list))
def __check_on_init_state_not_acceptance(Place, sm):
init_state = sm.get_init_state()
if init_state.is_acceptance():
error_msg("After '%s'" % Place + "\n" + \
"The initial state is 'acceptance'. This should never appear.\n" + \
"Please, log a defect at the projects website quex.sourceforge.net.\n")
for dummy in ifilter(lambda origin: origin.is_acceptance(),
init_state.origins()):
error_msg("After '%s'" % Place + "\n" + \
"Initial state contains an origin that is 'acceptance'. This should never appear.\n" + \
"Please, log a defect at the projects website quex.sourceforge.net.\n")
# (1) mark at each state machine the machine and states as 'original'.
#
# This is necessary to trace in the combined state machine the
# pattern that actually matched. Note, that a state machine in
# the StateMachine_List represents one possible pattern that can
# match the current input.
#
for sm in StateMachine_List:
if sm.get_id() in MarkNotSet: continue
sm.mark_state_origins()
assert sm.is_DFA_compliant(), sm.get_string(Option="hex")
# (2) setup all patterns in paralell
sm = parallelize.do(StateMachine_List,
CommonTerminalStateF=False) #, CloneF=False)
__check("Parallelization", sm)
# (4) determine for each state in the DFA what is the dominating original state
if FilterDominatedOriginsF: sm.filter_dominated_origins()
__check("Filter Dominated Origins", sm)
# (3) convert the state machine to an DFA (paralellization created an NFA)
sm = beautifier.do(sm)
__check("NFA to DFA, Hopcroft Minimization", sm)
return sm
def get_combined_state_machine(StateMachine_List, FilterDominatedOriginsF=True):
"""Creates a DFA state machine that incorporates the paralell
process of all pattern passed as state machines in
the StateMachine_List. Each origins of each state machine
are kept in the final state, if it is not dominated.
Performs: -- parallelization
-- translation from NFA to DFA
-- Frank Schaefers Adapted Hopcroft optimization.
Again: The state machine ids of the original state machines
are traced through the whole process.
FilterDominatedOriginsF, if set to False, can disable the filtering
of dominated origins. This is important for pre-conditions, because,
all successful patterns need to be reported!
"""
def __check(Place, sm):
__check_on_orphan_states(Place, sm)
__check_on_init_state_not_acceptance(Place, sm)
def __check_on_orphan_states(Place, sm):
orphan_state_list = sm.get_orphaned_state_index_list()
if len(orphan_state_list) == 0:
return
error_msg(
"After '%s'" % Place
+ "\n"
+ "Orphaned state(s) detected in regular expression (optimization lack).\n"
+ "Please, log a defect at the projects website quex.sourceforge.net.\n"
+ "Orphan state(s) = "
+ repr(orphan_state_list)
+ "\n"
)
def __check_on_init_state_not_acceptance(Place, sm):
init_state = sm.get_init_state()
if init_state.is_acceptance():
error_msg(
"After '%s'" % Place
+ "\n"
+ "The initial state is 'acceptance'. This should never appear.\n"
+ "Please, log a defect at the projects website quex.sourceforge.net.\n"
)
for dummy in ifilter(lambda origin: origin.is_acceptance(), init_state.origins()):
error_msg(
"After '%s'" % Place
+ "\n"
+ "Initial state contains an origin that is 'acceptance'. This should never appear.\n"
+ "Please, log a defect at the projects website quex.sourceforge.net.\n"
)
# (1) mark at each state machine the machine and states as 'original'.
#
# This is necessary to trace in the combined state machine the
# pattern that actually matched. Note, that a state machine in
# the StateMachine_List represents one possible pattern that can
# match the current input.
#
for sm in StateMachine_List:
sm.mark_state_origins()
for sm in StateMachine_List:
assert sm.is_DFA_compliant(), repr(sm)
# (2) setup all patterns in paralell
sm = parallelize.do(StateMachine_List, CommonTerminalStateF=False) # , CloneF=False)
__check("Parallelization", sm)
# (4) determine for each state in the DFA what is the dominating original state
if FilterDominatedOriginsF:
sm.filter_dominated_origins()
__check("Filter Dominated Origins", sm)
# (3) convert the state machine to an DFA (paralellization created an NFA)
sm = beautifier.do(sm)
__check("NFA to DFA, Hopcroft Minimization", sm)
return sm
