File: prebuilt_call.py

package info (click to toggle)
simpleparse 2.1.0a1-6
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd, wheezy
  • size: 2,776 kB
  • ctags: 4,332
  • sloc: python: 7,036; ansic: 6,395; makefile: 22
file content (62 lines) | stat: -rwxr-xr-x 2,236 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
"""Example using pre-built "re" parsing object

The Pre-built Element Token lets you include elements
which cannot be readily defined in the SimpleParse EBNF
including items defined by a callout to a Python
function.  This example demonstrates the technique.

The example also (obviously) demonstrates the use of an
re object during the parsing process.
"""
import re
from simpleparse.stt.TextTools.TextTools import *
from simpleparse.parser import Parser
from simpleparse import dispatchprocessor

class REMatch:
	"""An object wrapping a regular expression with __call__ (and Call) semantics"""
	def __init__( self, expression, flags=0 ):
		self.matcher = re.compile( expression, flags )
	def __call__( self, text, position, endPosition ):
		"""Return new text position, if > position, then matched, otherwise fails"""
		result = self.matcher.match( text, position, endPosition)
		if result:
			return result.end()
		else:
			# doesn't necessarily mean it went forward, merely
			# that it was satisfied, which means that an optional
			# satisfied but un-matched re will just get treated
			# like an error :(
			return position
	def table( self ):
		"""Build the TextTools table for the object"""
		return ( (None, Call, self ), )

declaration = r"""
v :=  white?,(word,white?)+
"""

class WordProcessor( dispatchprocessor.DispatchProcessor ):
	"""Processor sub-class defining processing functions for the productions"""
	# you'd likely provide a "resetBeforeParse" method
	# in a real-world application, but we don't store anything
	# in our parser.
	def word( self, tup, buffer ):
		"""Deal with a "word" production by printing out value"""
		print "word: ", repr(dispatchprocessor.getString(tup, buffer))
	def white( self, tup, buffer ):
		"""Deal with a "white" production by printing out value"""
		print "white:", repr(dispatchprocessor.getString(tup, buffer))


parser = Parser( declaration, "v", prebuilts = [
	("word", REMatch( "\w+").table()),
	("white", REMatch( "\W+").table()),
])

if __name__ == "__main__":
	print """Please enter some number of words seperated by whitespace.
We will attempt to parse them and return the parse results"""
	data = raw_input( ">>> " )
	parser.parse( data , processor = WordProcessor())