"""Abstract representation of an in-memory grammar that generates parsers"""
from simpleparse.stt.TextTools import TextTools
import traceback
class Generator:
'''Abstract representation of an in-memory grammar that generates parsers
The generator class manages a collection of
ElementToken objects. These element token objects
allow the generator to be separated from the import
particular parser associated with any particular EBNF
grammar. In fact, it is possible to create entire grammars
using only the generator objects as a python API.
'''
def __init__( self ):
"""Initialise the Generator"""
self.names = []
self.rootObjects = []
self.methodSource = None
self.definitionSources = []
def getNameIndex( self, name ):
'''Return the index into the main list for the given name'''
try:
return self.names.index( name )
except ValueError:
for source in self.definitionSources:
if source.has_key( name ):
return self.addDefinition( name, source[name])
## import pdb
## pdb.set_trace()
raise NameError( '''The name %s is not defined within this generator'''%(repr(name)), self )
def getRootObjects( self, ):
'''Return the list of root generator objects'''
return self.rootObjects
def getNames( self, ):
'''Return the list of root generator objects'''
return self.names
def getRootObject( self, name ):
"""Get a particular root object by name"""
return self.getRootObjects()[ self.getNameIndex(name)]
def addDefinition( self, name, rootElement ):
'''Add a new definition (object) to the generator'''
try:
self.names.index( name )
raise NameError( '''Attempt to redefine an existing name %s'''%(name), self )
except ValueError:
self.names.append( name )
self.rootObjects.append( rootElement )
return self.getNameIndex( name )
def buildParser( self, name, methodSource=None ):
'''Build the given parser definition, returning a TextTools parsing tuple'''
self.parserList = []
self.terminalParserCache = {}
self.methodSource = methodSource
i = 0
while i < len(self.rootObjects):
# XXX Note: rootObjects will grow in certain cases where
# a grammar is loading secondary grammars into itself
rootObject = self.rootObjects[i]
try:
if len(self.parserList) <= i or self.parserList[i] is None:
parser = tuple(rootObject.toParser( self ))
self.setTerminalParser( i, parser )
except NameError,err:
currentRuleName = self.names[i]
err.args = err.args + ('current declaration is %s'%(currentRuleName), )
raise
i = i + 1
assert None not in self.parserList, str( self.parserList)
return self.parserList [self.getNameIndex (name)]
def setTerminalParser( self, index, parser ):
"""Explicitly set the parser value for given name"""
while index >= len(self.parserList):
self.parserList.append(None)
self.parserList[index] = parser
def getTerminalParser( self, index ):
"""Try to retrieve a parser from the parser-list"""
try:
return self.parserList[ index ]
except IndexError:
return None
def cacheCustomTerminalParser( self, index, flags, parser ):
"""Optimization to reuse customized terminal parsers"""
self.terminalParserCache[ (index,flags) ] = parser
def getCustomTerminalParser( self, index, flags ):
"""Retrieved a cached customized terminal parser or None"""
return self.terminalParserCache.get( (index, flags))
def getParserList (self):
return self.parserList
def getObjectForName( self, name):
"""Determine whether our methodSource has a parsing method for the given name
returns ( flags or 0 , tagobject)
"""
testName = "_m_"+name
if hasattr( self.methodSource, testName):
method = getattr( self.methodSource, testName )
if callable(method):
return TextTools.CallTag, method
elif method == TextTools.AppendMatch:
return method, name
elif method in (TextTools.AppendToTagobj, TextTools.AppendTagobj):
object = self.getTagObjectForName( name )
if method == TextTools.AppendToTagobj:
if not ( hasattr( object, 'append') and callable(object.append)):
raise ValueError( """Method source %s declares production %s to use AppendToTagobj method, but doesn't given an object with an append method in _o_%s (gave %s)"""%(repr(self.methodSource), name,name, repr(object)))
return method, object
else:
raise ValueError( """Unrecognised command value %s (not callable, not one of the Append* constants) found in methodSource %s, name=%s"""%( repr(method),repr(methodSource),name))
return 0, name
def getTagObjectForName( self, name ):
"""Get any explicitly defined tag object for the given name"""
testName = "_o_"+name
if hasattr( self.methodSource, testName):
object = getattr( self.methodSource, testName )
return object
return name
def addDefinitionSource( self, item ):
"""Add a source for definitions when the current grammar doesn't supply
a particular rule (effectively common/shared items for the grammar)."""
self.definitionSources.append( item )
### Compatability API
## This API exists to allow much of the code written with SimpleParse 1.0
## to work with SimpleParse 2.0
class GeneratorAPI1:
"""Stand-in class supporting operation of SimpleParse 1.0 applications
There was really only the one method of interest, parserbyname,
everything else was internal (and is now part of
simpleparsegrammar.py).
"""
def __init__( self, production, prebuilt=() ):
from simpleparse.parser import Parser
self.parser = Parser( production, prebuilts=prebuilt )
def parserbyname( self, name ):
"""Retrieve a tag-table by production name"""
return self.parser.buildTagger( name )
def buildParser( declaration, prebuiltnodes=() ):
"""API 1.0 primary entry point, returns a GeneratorAPI1 instance
That object will respond to the parserbyname API expected by
SimpleParse 1.0 applications.
"""
return GeneratorAPI1( declaration, prebuiltnodes )
|