from parcon import number, Forward, InfixExpr
import operator
expr = Forward()
term = number[float] | "(" + expr + ")"
term = InfixExpr(term, [("*", operator.mul), ("/", operator.truediv)])
term = InfixExpr(term, [("+", operator.add), ("-", operator.sub)])
expr << term(name="expr")
print expr.parse_string("1+2") # prints 3
print expr.parse_string("1+2+3") # prints 6
print expr.parse_string("1+2+3+4") # prints 10
print expr.parse_string("3*4") # prints 12
print expr.parse_string("5+3*4") # prints 17
print expr.parse_string("(5+3)*4") # prints 32
print expr.parse_string("10/4") # prints 2.5
if not value[0].islower():
return Error('BadParameterName', 'Parameter names must not be capitalized', position, LINES)
return None
@rule(sp(1) + ':' + sp(1) + className + (',' + sp(1) + className)[...])
def baseClasses(value):
"""List of base classes."""
return justErrors(value)
@rule('(' + -anyIdentifier + ')')
def category(value):
return justErrors(value)
filePart = Forward() # Breaking naming scheme to match functions. # pylint: disable=C0103
@rule(Literal('@end'))
def end(_):
"""End of an interface, protocol, or implementation."""
return None
@rule(First('long', 'short') + ' ' + xsp)
def cTypeSizeModifier(value):
"""A type size modifier."""
return justErrors(value)
@rule(Regex(r'((signed|unsigned)\s+)?((long|short)\s+){0,2}(long|int|double|float|short)\b'))
m_keywords = m_and | m_or | m_not
m_identifier = W(alphanum_chars + alphas8bit + '_',
init_chars=alpha_chars + alphas8bit + '_') - m_keywords
m_identifier = m_identifier(name='NAME')
test('m_identifier', '''
a
abc
_abc
abc1
''')
m_expression = Forward()
m_infix_operator = m_logical_operator(name='⧽X⧼')
m_prefix_operator = m_not
m_subexpression = '(' + m_expression + ')'
m_term = m_literal | (m_identifier) | (m_subexpression)
m_expression_tail = Forward()
m_infix_expression = m_term + m_expression_tail
m_expression_tail << ((m_infix_operator + m_expression + m_expression_tail)
| (Return(None)))
"""
m_infix_expression = (
| (m_term + m_infix_operator + m_expression)
| (m_expression + m_infix_operator + m_term)
)
def parse_newick(text):
import operator
from parcon import Alpha, Digit, ZeroOrMore, Optional, Forward, OneOrMore, Longest, flatten, InfixExpr, CharIn
labels = {}
class ZNode(object):
def __init__(self, label=None, length=None):
self.label = label
self.length = length
self.children = []
self.parent = None
def add_child(self, node):
node.parent = self
self.children.append(node)
def ancestors(self):
pairs = [(self, 0)]
node = self
while node.parent:
pairs.append((node.parent, pairs[-1][1] + 1))
node = node.parent
return pairs
def __str__(self):
return "{}[{}]:{}".format(self.label,
''.join(map(str,
self.children)), self.length)
def __repr__(self):
s = "<%s" % (self.label or "?", )
if self.children:
s += " " + ", ".join(map(repr, self.children))
s += ">"
return s
def make_leaf(ast):
# print "leaf ast", ast
label = ast
node = ZNode(label=label)
if label:
labels[label] = node
return node
def make_internal(ast):
# print "internal ast", ast
if isinstance(ast[0], ZNode):
node = ZNode()
children = ast
else:
label = ast[-1]
node = ZNode(label=label)
if label:
labels[label] = node
children = ast[-2]
for n in children:
node.add_child(n)
return node
def test(args):
# print "matched:", args
return args
Name = ZeroOrMore(Alpha() | CharIn("_"))[''.join]
Leaf = Name
Node = Forward()
Internal = ("(" + InfixExpr(Node[lambda x: [x]], [(",", operator.add)]) +
")") + Optional(Name)
Node << (Internal[make_internal] | Leaf[make_leaf])
Tree = Node + ";"
return Tree.parse_string(text), labels
