def __init__(self, code):
self.tree = MyParser(code).ast
buildPrunnedTree(self.tree)
analysis(self.tree)
verifyNotUsedVariables(self.tree)
print("")
printPrunnedTree(self.tree)
def loadGrammar(self, grammarFilename):
preprocessed = self.preprocess_grammar(grammarFilename)
self.neighbours = self.find_neighbours_of_variables()
# self.parser = nltk.load_parser(grammarFilename, trace=1 if settings.VERBOSE["Parse"] else 0, cache=False) #nciht mehr parse.[...]
# self.parser = nltk.parse.FeatureEarleyChartParser(nltk.grammar.FeatureGrammar.fromstring(preprocessed), trace=settings.VERBOSE["Parse"])
self.parser = MyParser(
nltk.grammar.FeatureGrammar.fromstring(preprocessed),
trace=settings.VERBOSE["Parse"])
def run_weather_bot(serve_forever=True):
interpreter = MyParser()
agent = Agent.load('./models/dialogue', interpreter=interpreter)
if serve_forever:
agent.handle_channel(ConsoleInputChannel())
return agent
def compile(source, isFile=False):
text = InputStream(source)
if isFile:
text = FileStream(source)
lexer = DecafeLexer(text)
stream = CommonTokenStream(lexer)
parser = MyParser(stream)
tree = parser.program()
errors = parser.errMsg
# print(Trees.toStringTree(tree, None, parser))
tsymbol = MyVistor()
# make symbol table
tsymbol.visit(tree)
# tsymbol.symTable.Print() # print table
symTable = tsymbol.symTable.ToString() # get json of tables
# make tree
treeView, _ = convertor.convertInit(tree)(tree, 0)
treeView.render('tree.gv', "./web/static/img")
# intermediate code
inCode = IntermediateCodeGenerator(tsymbol.symTable)
inCode.visit(tree)
iCode = []
for l in inCode.lines:
if l.type != "label":
iCode.append("\t" + str(l))
else:
iCode.append(str(l))
iCode = "\n".join(iCode)
# compile to NASM
symT = tsymbol.symTable
with open('code.asm', 'w') as f:
for line in translate(symT, inCode.lines):
f.write("%s\n" % line)
print(iCode)
errors.extend(tsymbol.errorMsg)
errors = list(set(errors))
return symTable, errors, iCode
def main():
parser = argparse.ArgumentParser(
description=
"trivial right-branching parser that ignores any grammar passed in",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
addonoffarg(parser, 'debug', help="debug mode", default=False)
parser.add_argument("--infile",
"-i",
nargs='?',
type=argparse.FileType('r'),
default=sys.stdin,
help="input (one sentence per line strings) file")
parser.add_argument("--grammarfile",
"-g",
nargs='?',
type=argparse.FileType('r'),
default=sys.stdin,
help="grammar file; ignored")
parser.add_argument("--outfile",
"-o",
nargs='?',
type=argparse.FileType('w'),
default=sys.stdout,
help="output (one tree per line) file")
try:
args = parser.parse_args()
except IOError as msg:
parser.error(str(msg))
workdir = tempfile.mkdtemp(prefix=os.path.basename(__file__),
dir=os.getenv('TMPDIR', '/tmp'))
def cleanwork():
shutil.rmtree(workdir, ignore_errors=True)
if args.debug:
print(workdir)
else:
atexit.register(cleanwork)
infile = prepfile(args.infile, 'r')
outfile = prepfile(args.outfile, 'w')
grammarfile = prepfile(args.grammarfile, 'r')
# Create an instance of PCFGParser using data/weighted.rule grammar file
my_grammer = MyParser()
#print rules
# To use your own grammar file:
# parser = PCFGParser('grammar.txt')
tim = []
lent = []
for sentence in infile:
t0 = time.time()
parse_tree = my_grammer.parse(sentence.strip())
t1 = time.time()
tot = round(float((t1 - t0)), 5)
tim.append(tot)
lent.append(round(float(((len(sentence.split())))), 5))
outfile.write('{0}\n'.format(parse_tree))
outfile.close()
def setUp(self):
self.parser = MyParser()
Constant.clean_up()
BinOp.clean_up()
BinOpReversable.clean_up()
from myparser import MyParser
if __name__ == "__main__":
parser = MyParser()
while True:
# getting input and parse while 'ctrl+d' pressed
try:
s = input('Input Exp >>>> ')
except EOFError:
break
if not s:
continue
result = parser.parse(s)
print(f"Result Is -> { {result} }\n")
