def identifier():
whitespace()
not_followed_by(p(choice, *[p(reserved, rw) for rw in reserved_words]))
first = identifier_char1()
commit()
rest = many(identifier_char)
name = u''.join([first] + rest)
return ('ident', name)
def _ParseParam(self):
"""Consumes parameter keys for lookup in a parameter dictionary passed in with the query.
Parameter keys may consist of letters, digits and underscores (_).
Returns the value that the parameter key maps to.
"""
one_of('{')
param_name = ''.join(many_until1(p(one_of, letters + digits + '_'), p(one_of, '}'))[0])
return Parameter(param_name)
def test_choice_commit_fail(self):
def fun():
self.bw.next()
self.bw.commit()
self.bw.fail()
self.assertRaises(NoMatch, p(self.bw.choice, fun))
self.assertEquals(self.bw.peek(), 'b')
def string_literal():
whitespace()
quote = one_of('\'"')
commit()
st = u''.join(many1(p(string_char, quote)))
one_of(quote)
return ('str', st)
def test_choice_commit_fail(self):
def fun():
self.bw.next()
self.bw.commit()
self.bw.fail()
self.assertRaises(NoMatch, p(self.bw.choice, fun))
self.assertEquals(self.bw.peek(), 'b')
def number():
whitespace()
lead = u''.join(many1(digit))
commit()
if optional(p(one_of, '.')):
trail = u''.join(many1(digit))
return ('float', float(lead + '.' + trail))
else:
return ('int', int(lead))
def __init__(self, schema, parse_phrase_func=None):
self._schema = schema
if not parse_phrase_func:
parse_phrase_func = self._ParsePhrase
self._op_classes = {'|': Union, '-': Difference,
'&': Intersection, '+': PositionalIntersection}
self._operator = p(lexeme, p(one_of, u''.join(self._op_classes.keys())))
token_char = p(one_of, letters + digits + ':_')
self._token = as_string(p(many1, token_char))
self._phrase = p(choice, quoted, self._token)
self._param_parser = p(choice, self._ParseParam, quoted, self._token)
self._term_parser = p(choice, self._ParseParenthetical, parse_phrase_func)
self._expr_parser = p(choice, self._ParseOp, self._term_parser)
def __init__(self, table, raw=False): self._table = table self._raw = raw self._updates = dict() token_char = p(one_of, letters + digits + '.-_') self._token = as_string(p(many, token_char)) self._phrase = p(choice, quoted, self._token) self._expr_parser = p(many, p(choice, p(one_of, ','), self._ParsePhrase))
def __init__(self, table, raw=False):
self._table = table
self._raw = raw
self._updates = dict()
token_char = p(one_of, letters + digits + '.-_')
self._token = as_string(p(many, token_char))
self._phrase = p(choice, quoted, self._token)
self._expr_parser = p(many, p(choice, p(one_of, ','),
self._ParsePhrase))
def test_choice_fail(self):
self.assertRaises(NoMatch, p(self.bw.choice, self.bw.fail,
self.bw.fail))
def test_tri_fail(self):
def fun():
self.bw.next()
self.bw.fail()
self.assertRaises(NoMatch, p(self.bw.tri, fun))
def test_tri_fail(self):
def fun():
self.bw.next()
self.bw.fail()
self.assertRaises(NoMatch, p(self.bw.tri, fun))
def test_choice_fail(self):
self.assertRaises(NoMatch, p(self.bw.choice, self.bw.fail, self.bw.fail))
def bracketed():
one_of('[')
v = expression()
one_of(']')
return ['bracket', v]
def braced():
one_of('{')
v = expression()
one_of('}')
return ['brace', v]
def parened():
one_of('(')
v = expression()
one_of(')')
return ['paren', v]
part = p(choice, bracketed, braced, parened)
expression = p('expression', many, part)
if __name__ == "__main__":
text = ''
if len(sys.argv) > 1:
text = sys.argv[1]
print run_text_parser(p(cue, whitespace, part), text)
def where_expression():
reserved('where')
return sep1(let_binding, p(special, ','))
def let_expression():
reserved('let')
bindings = sep1(let_binding, p(special, ','))
reserved('in')
expr = expression()
return ('let', bindings, expr)
import sys
def bracketed():
one_of('[')
v = expression()
one_of(']')
return ['bracket', v]
def braced():
one_of('{')
v = expression()
one_of('}')
return ['brace', v]
def parened():
one_of('(')
v = expression()
one_of(')')
return ['paren', v]
part = p(choice, bracketed, braced, parened)
expression = p('expression', many, part)
if __name__ == "__main__":
text = ''
if len(sys.argv) > 1:
text = sys.argv[1]
print run_text_parser(p(cue, whitespace, part), text)
sys.path.insert(0, path.abspath(path.join(path.dirname(sys.argv[0]), '..')))
import unittest
from picoparse import partial as p
from picoparse import run_parser as run, NoMatch
from picoparse import any_token, one_of, not_one_of, satisfies, eof
from picoparse import many, many1, many_until, many_until1, n_of, optional
from picoparse import sep, sep1
from picoparse import cue, follow, seq, string
from picoparse import not_followed_by, remaining
from utils import ParserTestCase
# some simple parsers
nothing = p(one_of, '')
everything= p(not_one_of, '')
one_a = p(one_of, 'a')
not_a = p(not_one_of, 'a')
one_a_or_b = p(one_of, 'ab')
not_a_or_b = p(not_one_of, 'ab')
always_satisfies = p(satisfies, lambda i: True)
never_satisfies = p(satisfies, lambda i: False)
one_b_to_d = p(satisfies, lambda i: 'b' <= i <= 'd')
class TestTokenConsumers(ParserTestCase):
"""This TestCase checks that all the primative token consumers work as expected.
"""
def testany_token(self):
self.assertMatch(any_token, 'a', 'a', '')
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
from picoparse import partial
from picoparse import one_of, optional, many, choice, p, cue
from picoparse.text import run_text_parser, whitespace
import sys
def matched(start, stop, name):
one_of(start)
v = expression()
one_of(stop)
return [name, v]
bracketed = p(matched, '[', ']', 'bracket')
braced = p(matched, '{', '}', 'brace')
parened = p(matched, '(', ')', 'paren')
part = p(choice, bracketed, braced, parened)
expression = p('expression', many, part)
if __name__ == "__main__":
text = ''
if len(sys.argv) > 1:
text = sys.argv[1]
print run_text_parser(p(cue, whitespace, part), text)
def operator():
whitespace()
not_followed_by(p(choice, *[p(reserved_op, op) for op in reserved_operators]))
name = u''.join(many1(operator_char))
return ('op', name)
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
from picoparse import partial
from picoparse import one_of, optional, many, choice, p, cue
from picoparse.text import run_text_parser, whitespace
import sys
def matched(start, stop, name):
one_of(start)
v = expression()
one_of(stop)
return [name, v]
bracketed = p(matched, '[', ']', 'bracket')
braced = p(matched, '{', '}', 'brace')
parened = p(matched, '(', ')', 'paren')
part = p(choice, bracketed, braced, parened)
expression = p('expression', many, part)
if __name__ == "__main__":
text = ''
if len(sys.argv) > 1:
text = sys.argv[1]
print run_text_parser(p(cue, whitespace, part), text)
'..')))
import unittest
from picoparse import partial as p
from picoparse import run_parser as run, NoMatch
from picoparse import any_token, one_of, not_one_of, satisfies, eof
from picoparse import many, many1, many_until, many_until1, n_of, optional
from picoparse import sep, sep1
from picoparse import cue, follow, seq, string
from picoparse import not_followed_by, remaining
from utils import ParserTestCase
# some simple parsers
nothing = p(one_of, '')
everything = p(not_one_of, '')
one_a = p(one_of, 'a')
not_a = p(not_one_of, 'a')
one_a_or_b = p(one_of, 'ab')
not_a_or_b = p(not_one_of, 'ab')
always_satisfies = p(satisfies, lambda i: True)
never_satisfies = p(satisfies, lambda i: False)
one_b_to_d = p(satisfies, lambda i: 'b' <= i <= 'd')
class TestTokenConsumers(ParserTestCase):
"""This TestCase checks that all the primative token consumers work as expected.
"""
def testany_token(self):
