Python Grammar.text_to_grammar方法代码示例

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def test_parser_code_production(self):
		s = "S -> A B C\n"
		s +="A -> a A | &\n"
		s +="B -> b B | A C d\n"
		s +="C -> c C | &"
		g = Grammar.text_to_grammar(s)
		r = RecursiveDescentParser(g)

		c = '''\
	A()
	B()
	C()'''
		self.assertEqual(c.strip(),r._parser_code_production(Production('S','A B C'),'S').strip())

		c = '''\
	if current_symbol == 'a':
		next_lexic_symbol()
	else:
		raise Exception('A','a',current_symbol)
	A()'''
		self.assertEqual(c.strip(),r._parser_code_production(Production('A','a A'),'A').strip())

		c = '''\
	A()
	C()
	if current_symbol == 'd':
		next_lexic_symbol()
	else:
		raise Exception('B','d',current_symbol)'''
		self.assertEqual(c.strip(),r._parser_code_production(Production('B','A C d'),'B').strip())

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def test_parser_code_nonterminal(self):
		s = "S -> A B C\n"
		s +="A -> a A | &\n"
		s +="B -> b B | A C d\n"
		s +="C -> c C | D\n"
		s +="D -> &"
		g = Grammar.text_to_grammar(s)
		r = RecursiveDescentParser(g)

		c = '''\
def S():
	global current_symbol
	if current_symbol in ['a', 'b', 'c', 'd']:
		A()
		B()
		C()
\t
	else:
		raise Exception('S',['a', 'b', 'c', 'd'],current_symbol)'''
		self.assertEqual(c.strip(),r._parser_code_nonterminal('S').strip())

		c = '''\
def A():
	global current_symbol
	if current_symbol in ['a']:
		if current_symbol == 'a':
			next_lexic_symbol()
		else:
			raise Exception('A','a',current_symbol)
		A()'''
		self.assertEqual(c.strip(),r._parser_code_nonterminal('A').strip())

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def verify_grammar_ll1(self):
		self.log('Verificando se a gramática é LL(1)')

		try:
			g = Grammar.text_to_grammar(self.ui.text_grammar.toPlainText())
		except Exception:
			QMessageBox.critical(self,'Erro durante criação da gramática','O texto que foi tentado a conversão para gramática não é válido')
			raise Exception('Erro durante criação da gramática','O texto que foi tentado a conversão para gramática não é válido')

		try:
			g.is_ll1(self.log)
			self.log('A gramática é LL(1)!')
			return True
		except Exception as err:
			if err.args[0] == 'LEFT_RECURSION':
				nts = ', '.join(err.args[1])
				QMessageBox.critical(self,'Recursão à esquerda','Os seguintes não terminais levam a uma recursão à esquerda:\n\t%s'%(nts))
				self.log('Recursão a esquerda encontrada encontrada nos não terminais: %s'%(nts))
				raise Exception('Recursão à esquerda','Os seguintes não terminais levam a uma recursão à esquerda: %s'%(nts))
			elif err.args[0] == 'LEFT_FACTORING':
				nts = ', '.join(err.args[1])
				QMessageBox.critical(self,'Fatoração à esquerda','Os seguintes não terminais não estão fatorados à esquerda:\n\t%s'%(nts))
				self.log('Não fatoração encontrada nos não terminais: %s'%(nts))
				raise Exception('Fatoração à esquerda','Os seguintes não terminais não estão fatorados à esquerda: %s'%(nts))
			elif err.args[0] == 'FIRST_FOLLOW_CONFLICT':
				nts = ', '.join(err.args[1])
				QMessageBox.critical(self,'Conflito first/follow','Houve conflito entre o first e o follow dos seguintes não terminais:\n\t%s'%(nts))
				self.log('Conflito first/follow encontrado nos não terminais: %s'%(nts))
				raise Exception('Conflito first/follow','Houve conflito entre o first e o follow dos seguintes não terminais: %s'%(nts))
			else:
				QMessageBox.critical(self,'Erro inesperado durante verificação LL(1)',err.__repr__())
				raise Exception('Erro inesperado durante verificação LL(1)',err.__repr__())

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def btn_parser_clicked(self):
		if(self.verify_grammar_ll1()):
			g = Grammar.text_to_grammar(self.ui.text_grammar.toPlainText())
			r = RecursiveDescentParser(g)
			self._current_parser = r
			self.ui.text_parser.setText(r.parser_code(self.log).strip().replace('\t','    '))
			QMessageBox.information(self,'Geração do parser descendente recursivo','O parser foi gerado!')

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def test_text_to_grammar(self):
		s = "S -> a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._productions, {Production('S','a')})

		s = "S -> b S | a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._productions, {Production('S','a'), Production('S',['b','S'])})

		s = "S1 -> b S1 a | a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._productions, {Production('S1','a'), Production('S1',['b','S1','a'])})

		s = "C -> if E then C C' | comando\n"
		s +="C' -> else C | &\n"
		s +="E -> exp"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._productions, {Production("C","if E then C C'"), Production("C","comando"),\
		 Production("C'","else C"), Production("C'","&"), Production("E","exp")})

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def gr_fa_btn_clicked(self, table):
		st = self.ui.gr_text.toPlainText()
		if st == '':
			st = "S -> aS | a | bS | b"

		gr = Grammar.text_to_grammar(st)
		fa = gr.to_finite_automaton()

		self.add_fa_on_list("GR => FA", fa)
		self.set_fa_on_table(fa, table)

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def er_equals_gr_btn_clicked(self):
		st = self.ui.gr_text.toPlainText()
		if st == '':
			st = "S -> aS | a | bS | b"
		gr = Grammar.text_to_grammar(st)
		fa_gr = gr.to_finite_automaton()

		st = self.ui.er_text.toPlainText()
		if st == '':
			st = "(0*(1(01*0)*1)*0*)*"
		fa_er = RegularExpression(st).to_deterministic_finite_automaton()

		if fa_gr.is_equal(fa_er):
			QMessageBox.about(self,"Equivalência entre GR e ER","A Expressão Regular é equivalente à Gramática Regular")
		else:
			QMessageBox.about(self,"Equivalência entre GR e ER","A Expressão Regular NÃO é equivalente à Gramática Regular")

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def test_first(self):
		s = "S -> a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._first('S'),{'a'})
		self.assertEqual(g._first('a'),{'a'})
		self.assertEqual(g._first('a b S c S t e'),{'a'})

		s = "S -> b S | a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._first('S'),{'a','b'})

		s = "S1 -> b S1 a | a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._first("S1"),{'a','b'})

		s = "C -> if E then C C' | comando\n"
		s +="C' -> else C | &\n"
		s +="E -> exp"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._first("C"),{'if','comando'})
		self.assertEqual(g._first("C'"),{'else','&'})
		self.assertEqual(g._first("E"),{'exp'})
		self.assertEqual(g._first("E C"),{'exp'})
		self.assertEqual(g._first("C' E"),{'else','exp'})

		s = "S -> A b | A B c\n"
		s +="B -> b B | A d | &\n"
		s +="A -> a A | &"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._first("S"),{'a','b','c','d'})
		self.assertEqual(g._first("B"),{'a','b','d','&'})
		self.assertEqual(g._first("A"),{'a','&'})

		s = "S -> A B C\n"
		s +="A -> a A | &\n"
		s +="B -> b B | A C d\n"
		s +="C -> c C | &"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._first("S"),{'a','b','c','d'})
		self.assertEqual(g._first("B"),{'b','a','c','d'})
		self.assertEqual(g._first("A"),{'a','&'})
		self.assertEqual(g._first("C"),{'c','&'})

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def test_follow(self):
		s = "S -> a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._follow('S'),{'$'})

		s = "S -> b S | a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._follow('S'),{'$'})

		s = "S1 -> b S1 a | a"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._follow("S1"),{'$','a'})

		s = "C -> if E then C C' | comando\n"
		s +="C' -> else C | &\n"
		s +="E -> exp"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._follow("C"),{'$','else'})
		self.assertEqual(g._follow("C'"),{'$','else'})
		self.assertEqual(g._follow("E"),{'then'})

		s = "S -> A b | A B c\n"
		s +="B -> b B | A d | &\n"
		s +="A -> a A | &"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._follow("S"),{'$'})
		self.assertEqual(g._follow("B"),{'c'})
		self.assertEqual(g._follow("A"),{'a','b','c','d'})

		s = "S -> A B C\n"
		s +="A -> a A | &\n"
		s +="B -> b B | A C d\n"
		s +="C -> c C | &"
		g = Grammar.text_to_grammar(s)
		self.assertEqual(g._follow("S"),{'$'})
		self.assertEqual(g._follow("B"),{'c','$'})
		self.assertEqual(g._follow("A"),{'a','b','c','d'})
		self.assertEqual(g._follow("C"),{'d','$'})

# 需要导入模块: from grammar import Grammar [as 别名]
# 或者: from grammar.Grammar import text_to_grammar [as 别名]
	def test_have_left_recursion(self):
		s = "A -> F C a | E A\nB -> C G h\nC -> D B a | b h | c | epsilon\nD -> F e | epsilon\nE -> G h | D f\nF -> E A | d F | epsilon\nG -> g"
		g = Grammar.text_to_grammar(s)
		pass