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 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 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 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):