def norm(formula):
'''Computes the bounds of the given TWTL formula and returns a 2-tuple
containing the lower and upper bounds, respectively.
'''
lexer = twtlLexer(ANTLRStringStream(formula))
tokens = CommonTokenStream(lexer)
parser = twtlParser(tokens)
phi = parser.formula()
# CommonTree
t = phi.tree
# compute TWTL bound
nodes = CommonTreeNodeStream(t)
nodes.setTokenStream(tokens)
boundEvaluator = bound(nodes)
boundEvaluator.eval()
return boundEvaluator.getBound()
def translate(formula, kind='both', norm=False, optimize=True):
'''Converts a TWTL formula into an FSA. It can returns both a normal FSA or
the automaton corresponding to the relaxed infinity version of the
specification.
If kind is: (a) DFAType.Normal it returns only the normal version;
(b) DFAType.Infinity it returns only the relaxed version; and
(c) 'both' it returns both automata versions.
If norm is True then the bounds of the TWTL formula are computed as well.
The functions returns a tuple containing in order: (a) the alphabet;
(b) the normal automaton (if requested); (c) the infinity version automaton
(if requested); and (d) the bounds of the TWTL formula (if requested).
The ``optimize'' flag is used to specify that the annotation data should be
optimized. Note that the synthesis algorithm assumes an optimized automaton,
while computing temporal relaxations is performed using an unoptimized
automaton.
'''
if kind == 'both':
kind = [DFAType.Normal, DFAType.Infinity]
elif kind in [DFAType.Normal, DFAType.Infinity]:
kind = [kind]
else:
raise ValueError('DFA type must be either DFAType.Normal, ' +
'DFAType.Infinity or "both"! {} was given!'.format(kind))
lexer = twtlLexer(ANTLRStringStream(formula))
lexer.setAlphabet(set())
tokens = CommonTokenStream(lexer)
parser = twtlParser(tokens)
phi = parser.formula()
# CommonTree
t = phi.tree
alphabet = lexer.getAlphabet()
result= [alphabet]
if DFAType.Normal in kind:
setDFAType(DFAType.Normal)
nodes = CommonTreeNodeStream(t)
nodes.setTokenStream(tokens)
translator = twtl2dfa(nodes)
translator.props = alphabet
translator.eval()
dfa = translator.getDFA()
dfa.kind = DFAType.Normal
result.append(dfa)
if DFAType.Infinity in kind:
setDFAType(DFAType.Infinity)
setOptimizationFlag(optimize)
nodes = CommonTreeNodeStream(t)
nodes.setTokenStream(tokens)
translator = twtl2dfa(nodes)
translator.props = alphabet
translator.eval()
dfa_inf = translator.getDFA()
dfa_inf.kind = DFAType.Infinity
result.append(dfa_inf)
if norm: # compute TWTL bound
nodes = CommonTreeNodeStream(t)
nodes.setTokenStream(tokens)
boundEvaluator = bound(nodes)
boundEvaluator.eval()
result.append(boundEvaluator.getBound())
if logging.getLogger().isEnabledFor(logging.DEBUG):
for mode, name in [(DFAType.Normal, 'Normal'),
(DFAType.Infinity, 'Infinity')]:
if mode not in kind:
continue
elif mode == DFAType.Normal:
pdfa = dfa
else:
pdfa = dfa_inf
logging.debug('[spec] spec: {}'.format(formula))
logging.debug('[spec] mode: {} DFA: {}'.format(name, pdfa))
if mode == DFAType.Infinity:
logging.debug('[spec] tree:\n{}'.format(pdfa.tree.pprint()))
logging.debug('[spec] No of nodes: {}'.format(pdfa.g.number_of_nodes()))
logging.debug('[spec] No of edges: {}'.format(pdfa.g.number_of_edges()))
return tuple(result)
