def getModel (inFile, inFormat = None, modelFactory = None):
"""getModel()
Simply a hook for model internalization to a BasilGrammarModel instance.
See the Basil Grammar Model and its internalize() method, most likely
inherrited from BaseModelFactory."""
retVal = None
if inFormat == None:
if inFile == None:
raise ModelInternalizationError("Can not guess stdin format if "
"none is specified.")
else:
import os.path
_, ext = os.path.splitext(inFile)
format = ext[1:].upper()
elif FORMAT_MAP.has_key(inFormat):
format = FORMAT_MAP[inFormat]
else:
raise ModelInternalizationError("Invalid model format: %s" % inFormat)
if modelFactory is None:
modelFactory = BasilGrammarModel.getModelFactory()()
if inFile == None:
targetFile = sys.stdin
else:
targetFile = open(inFile, "r")
try:
retVal = modelFactory.internalize(format, targetFile)
finally:
if inFile != None:
targetFile.close()
return retVal
def __init__ (self, factory = None):
"""PgenInternalizer.__init__
"""
self.factory = factory
if None == factory:
factoryClass = BasilGrammarModel.getModelFactory()
self.factory = factoryClass()
self._initializeModel()
def main (fileName = None):
"""main
Read a pgen input grammar from the given file name. If no file name is
given, read the grammar from stdin. Print a XML document for the
resulting grammar model translation.
"""
if None == fileName:
parseTree = PgenParser.parseString(sys.stdin.read())
else:
parseTree = PgenParser.parseFile(fileName)
grammarFactoryClass = BasilGrammarModel.getModelFactory()
grammarFactory = grammarFactoryClass()
internalizer = PgenInternalizer(grammarFactory)
model = internalizer(parseTree)
print grammarFactory.externalizeXML(model)
def __init__ (self, factory = None, symbolGenerator = None):
"""Despecializer.__init__
Associates a BasilGrammarModel factory with the handler. If none
is given, a new factory is instantiated from the default
BasilGrammarModel module.
"""
if None == factory:
factoryClass = BasilGrammarModel.getModelFactory()
factory = factoryClass()
if None == symbolGenerator:
symbolGenerator = simpleSymbolGen()
self.factory = factory
self.symbolGenerator = symbolGenerator
self._pendingProductions = []
self._leftRecursive = False
self._crntLHS = None
def main (fileName = None):
"""main()
Read a BNF input grammar from the given file name and print the XML
representation of the corresponding Basil grammar model.
"""
text = None
if None == fileName:
text = sys.stdin.read()
else:
inFile = open(fileName)
text = inFile.read()
inFile.close()
grammar = bnf.get_prods(text)
grammarFactoryClass = BasilGrammarModel.getModelFactory()
grammarFactory = grammarFactoryClass()
internalizer = BNFInternalizer(grammarFactory)
model = internalizer(grammar)
print grammarFactory.externalizeXML(model)
def main (fileName = None):
"""main()
"""
text = None
if None == fileName:
text = sys.stdin.read()
else:
inFile = open(fileName)
text = inFile.read()
inFile.close()
parser = BisonParser.BisonParser(text)
parser.parse()
grammarFactoryClass = BasilGrammarModel.getModelFactory()
grammarFactory = grammarFactoryClass()
internalizer = BisonInternalizer(grammarFactory)
prodList = map(lambda prodData : (prodData[1], prodData[2]),
parser.productions)
model = internalizer((parser.startVal, prodList))
print grammarFactory.externalizeXML(model)
pinfo.get_all()
prodparse = [ parse_grammar(doc_str, file_name, line_no)
for line_no, file_name, func_name, doc_str in pinfo.pfuncs ]
pprint.pprint(prodparse)
prodmap2 = {}
for parse_result in prodparse:
for file_name, line_no, nt, rhs in parse_result:
if nt not in prodmap2:
prodmap2[nt] = set()
prodmap2[nt].add(tuple(rhs))
print "_" * 60
pprint.pprint(prodmap2)
assert prodmap == prodmap2
# ______________________________________________________________________
# Let's build a BasilGrammarModel...
from basil.models.grammar import BasilGrammarModel
from basil.models.grammar.InternalizeBNF import BNFInternalizer
model_factory = BasilGrammarModel.getModelFactory()()
internalizer = BNFInternalizer(model_factory)
model = internalizer((pinfo.start, prodmap2))
print model_factory.externalizeXML(model)
