s = Nonterminal("Satz")
art = Nonterminal("Artikel")
nn = Nonterminal("Nomen")
np = Nonterminal("Nominalphrase")
vtr = Nonterminal("Transitives Verb")
adj = Nonterminal("Adjektiv")
# Definiert eine Grammatik, welche Sätze wie "Das alte Haus ist ein Ort" oder
# "Der Kiesweg ist ein Ort" parsen kann.
s >> np + vtr + np
np >> art + nn
vtr >> Terminal('ist')
art >> Terminal("der") | Terminal("die") | Terminal("das") | Terminal("ein") | Terminal("eine")
nn >> Terminal("haus") | Terminal("kiesweg") | Terminal("raum") | Terminal("ort")
p = RecursiveDescentParser(s)
def s_action(np1, verb, np2):
if np2 == 'raum':
np2 = 'ort'
if verb == 'ist':
return [np2, np1]
else:
raise ValueError("Kann keinen miniprolog-Fakt erzeugen")
def vtr_action(verb):
return verb
def np_action(artikel, nomen):
return nomen
# ausdruck beteht aus term, operator und ausdruck
print "term", args[1], "ausdruck -> ausdruck"
if args[1] == '+':
print " (", args[0], "+", args[2], "->", args[0] + args[2], ")"
return args[0] + args[2]
elif args[1] == '-':
print " (", args[0], "-", args[2], "->", args[0] + args[2], ")"
return args[0] - args[2]
def satz_action(ausdruck, fragezeichen):
print "ausdruck -> s"
print " (", ausdruck, "->", ausdruck, ")"
return ausdruck
p = RecursiveDescentParser(s, lambda t: t[0], lambda t: t[1])
p.setParseAction(s, satz_action)
p.setParseAction(zahl, zahl_action)
p.setParseAction(faktor, faktor_action)
p.setParseAction(term, term_action)
p.setParseAction(ausdruck, ausdruck_action)
# Erstellt einen einfachen Lexer
lex = makeLexer(['+','-','*','/','(',')',('ZAHL', r"[0-9]+"), (None, r"\s+")])
while True:
src = raw_input("Gib etwas ein: ")
src = src.lower()
DER = Terminal("der")
DIE = Terminal("die")
DAS = Terminal("das")
HAUS = Terminal("haus")
KIESWEG = Terminal("kiesweg")
ENTE = Terminal("ente")
# Definiert eine Grammatik, welche Sätze wie "Das alte Haus ist ein Ort" oder
# "Der Kiesweg ist ein Ort" parsen kann.
s >> art(gen='?g') + nn(gen = '?g')
art >> DER(gen='m') | DAS(gen='n') | DIE(gen='f')
nn >> HAUS(gen='n') | KIESWEG(gen='m') | ENTE(gen='f')
p = RecursiveDescentParser(s, lambda t: t["word"], lambda t: t)
while True:
src = raw_input("Gib etwas ein: ")
src = src.lower()
tokens = src.split(" ")
fttokens = [ {'word': x} for x in tokens ]
g = p.parse(fttokens)
try:
semantic = g.next()
print "Aha, ich verstehe:"
print semantic
except StopIteration:
print "Das verstehe ich leider nicht."
DER = Terminal("der")
DIE = Terminal("die")
DAS = Terminal("das")
HAUS = Terminal("haus")
KIESWEG = Terminal("kiesweg")
ENTE = Terminal("ente")
# Definiert mithilfe von Features eine Grammatik, welche die Satzfragmente
# "Das Haus", "Die Ente" und "Der Kiesweg" erkennen kann, aber nicht
# "Die Haus", "Das Ente" usw.
s >> art(gen='?g') + nn(gen = '?g')
art >> DER(gen='m') | DAS(gen='n') | DIE(gen='f')
nn >> HAUS(gen='n') | KIESWEG(gen='m') | ENTE(gen='f')
# Parser, der die oben definierte Sprache erkennt
p = RecursiveDescentParser(s, lambda t: t["word"], lambda t: t)
while True:
src = raw_input("Gib etwas ein: ")
src = src.lower()
tokens = src.split(" ")
# verwandelt die Liste von Worten in eine Liste von Dictionaries
fttokens = [ {'word': x} for x in tokens ]
semantic = p.first(fttokens)
if semantic != None:
print "Aha, ich verstehe:"
print semantic
else:
print "Das verstehe ich leider nicht."
def extractName(semantic):
if semantic[0] == 'name':
return semantic[1]
if semantic[0] == 'pron':
if semantic[1] == 'f':
return femaleReferent
elif semantic[1] == 'm':
return maleReferent
else:
return 'ich'
p = RecursiveDescentParser(s)
p.setParseAction(name, name_action)
p.setParseAction(perspron, perspron_action)
p.setParseAction(vtr, vtr_action)
p.setParseAction(adj, adj_action)
p.setParseAction(nn, nn_action)
p.setParseAction(np, np_action)
p.setParseAction(pp, pp_action)
p.setParseAction(s, s_action)
while True:
src = raw_input("Gib etwas ein: ")
src = src.lower()
tokens = src.split(" ")
s = Nonterminal("Satz")
ausdruck = Nonterminal("Ausdruck")
term = Nonterminal("Term")
faktor = Nonterminal("Faktor")
zahl = Nonterminal("Zahl")
# Definiert eine Grammatik, welche Ausdrücke wie 3 * 4 + 2 oder 3 * (4 + 2)
# beschreibt.
s >> ausdruck + Terminal("?")
ausdruck >> term | ausdruck + Terminal("+") + term | ausdruck + Terminal('-') + term
term >> faktor | faktor + Terminal("*") + term | faktor + Terminal("/") + term
faktor >> zahl | Terminal('(') + ausdruck + Terminal(')')
zahl >> Terminal('1') | Terminal('2') | Terminal('3') | Terminal('4')
p = RecursiveDescentParser(s)
while True:
src = raw_input("Gib etwas ein: ")
src = src.lower()
tokens = src.split(" ")
g = p.parse(tokens)
try:
semantic = g.next()
print "Aha, ich verstehe:"
pprint.pprint(semantic, indent=2)
print
except StopIteration:
print "Das verstehe ich nicht."
