File: baseparser.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 (66 lines) | stat: -rwxr-xr-x 2,472 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
63
64
65
66
"""Base class for real-world parsers (such as parser.Parser)"""
from simpleparse.stt.TextTools.TextTools import *
from simpleparse.generator import Generator

class BaseParser:
	"""Class on which real-world parsers build

	Normally you use a sub-class of this class, such as
	simpleparser.parser.Parser
	"""
	_rootProduction = ""
	# primary API...
	def parse( self, data, production=None, processor=None, start=0, stop=None):
		"""Parse data with production "production" of this parser

		data -- data to be parsed, a Python string, for now
		production -- optional string specifying a non-default production to use
			for parsing data
		processor -- optional pointer to a Processor or MethodSource object for
			use in determining reporting format and/or post-processing the results
			of the parsing pass.  Can be None if neither is desired (default)
		start -- starting index for the parsing, default 0
		stop -- stoping index for the parsing, default len(data)
		"""
		self.resetBeforeParse()
		if processor is None:
			processor = self.buildProcessor()
		if stop is None:
			stop = len(data)
		value = tag( data, self.buildTagger( production, processor), start, stop )
		if processor and callable(processor):
			return processor( value, data )
		else:
			return value
	# abstract methods
	def buildProcessor( self ):
		"""Build default processor object for this parser class

		The default implementation returns None.  The processor
		can either implement the "method source" API (just provides
		information about Callouts and the like), or the processor
		API and the method-source API.  The processor API merely
		requires that the object be callable, and have the signature:
		
			object( (success, children, nextPosition), buffer)

		(Note: your object can treat the first item as a single tuple
		if it likes).

		See: simpleparse.processor module for details.
		"""
		return None
	def buildTagger( self, name, processor ):
		"""Build the tag-table for the parser

		This method must be implemented by your base class and _not_
		call the implementation here.
		"""
		raise NotImplementedError( """Parser sub-class %s hasn't implemented a buildTagger method"""%(self.__class__.__name__))
	def resetBeforeParse( self ):
		"""Called just before the parser's parse method starts working,

		Allows you to set up special-purpose structures, such as stacks
		or local storage values.  There is no base implementation.  The
		base implementation does nothing.
		"""