Example #1
0
    def readAutomato():
        with open('InsiraSeuAutomatoAqui/automato.json') as file:
            automatoJson = json.load(file)

        alphabet = automatoJson["alfabeto"]
        stateInitial = automatoJson["estadoInicial"]
        stateEnd = automatoJson["estadoFinal"]
        transictions = automatoJson["transicoes"]

        newAutomato = Automato(alphabet, stateInitial, stateEnd, transictions)
        newAutomato.populateTransictions()

        return newAutomato
Example #2
0
def main():
    with open('automato.json') as f:
        data = json.load(f)

    alfabeto = data["alfabeto"]
    listaTransicoes = data["listaTransicoes"]
    estadoInicial = data["estadoInicial"]
    estadoFinal = data["estadoFinal"]
    automato = Automato(alfabeto, listaTransicoes, estadoInicial, estadoFinal)
    automato.createAutomato()

    while True:
        print("1. - Testar Palavra")
        print("2. - Minimizar Automato")
        print("3. - Finalizar")
        opc = int(input("opcao: "))
        if opc == 1:
            palavra = input("Informe a palavra: ")
            automato.testarAutomato(palavra)
        elif opc == 2:
            automato.minimizacao()
        elif opc == 3:
            break
        else:
            print("Opção invalida")
	def __init__(self, arq):
		self.reservadas = []
		self.delimitadores = []
		self.aut = Automato()
		self.arq = open(arq).readlines()
		self.linha_atual = 0
		self.col_atual = 0
Example #4
0
def automatoER(input):
    input = entrytext.get()
    l = Leitor(input)
    dict, ini, final = l.ler()
    a = Automato(dict,ini,final)
    er = a.automataToER()
    expressao = Er(er)
    expressao.printER()
    expressao.writeERToFile(input)

    input = input.replace('.in', '')
    data_file = open('../testes/'+input+'.out')
    data = data_file.read()
    data_file.close()
    test = Tk.Tk()
    Results = Tk.Label(test, text = data)
    Results.grid(row = 20, column = 3, sticky= Tk.W)
Example #5
0
def automatoGramatica(input):
    l = Leitor(input)
    dict, ini, final = l.ler()
    a = Automato(dict,ini,final)

    prod,terminais,nonTerminais,inicial = a.automataToGrammar()
    g = Grammar(prod,terminais,nonTerminais,inicial)
    g.printGrammar()
    g.writeGrammarToFile(input)

    input = input.replace('.in', '')
    data_file = open('../testes/'+input+'.out')
    data = data_file.read()
    data_file.close()
    test = Tk.Tk()
    Results = Tk.Label(test, text = data)
    Results.grid(row = 20, column = 3, sticky= Tk.W)
Example #6
0
def gramaticaAutomato(input):
    input = entrytext.get()
    l = LeitorG(input)
    dict, termi,nonter,ini = l.ler()
    g = Grammar(dict,termi,nonter,ini)
    s, inicial, final = g.convertGtoAF()
    a = Automato(s,inicial,final)
    a.printAtomato()
    a.writeAutomataToFile(input)

    input = input.replace('.in', '')
    data_file = open('../testes/'+input+'.out')
    data = data_file.read()
    data_file.close()
    test = Tk.Tk()
    Results = Tk.Label(test, text = data)
    Results.grid(row = 20, column = 3, sticky= Tk.W)
Example #7
0
def main():
    arquivo = FileStream("Automato.txt")
    fita = input("Digite a fita de definicao:")
    lexer = AutomatonGrammarLexer(arquivo)
    stream = CommonTokenStream(lexer)
    parser = AutomatonGrammarParser(stream)
    tree = parser.s()

    definicao = Listener()
    walker = ParseTreeWalker()
    walker.walk(definicao, tree)

    definicao.transicoes = definicao.transicoes[0].replace(",(",
                                                           ";(").split(";")
    for cont in range(len(definicao.transicoes)):
        definicao.transicoes[cont] = definicao.transicoes[cont].replace(
            "(", "")
        definicao.transicoes[cont] = definicao.transicoes[cont].replace(
            ")", "")
        definicao.transicoes[cont] = definicao.transicoes[cont].replace(
            "=", ",")
        definicao.transicoes[cont] = definicao.transicoes[cont].split(",")

    print("Alfabeto: ")
    print(definicao.alfabeto)
    print("Estados: ")
    print(definicao.estados)
    print("Transicoes: ")
    print(definicao.transicoes)
    print("Estado inicial: ")
    print(definicao.inicio)
    print("Estados Finais: ")
    print(definicao.final)
    auto = Automato(definicao, fita)
    if auto.valida():
        print("Entrada RECONHECIDA")
    else:
        print("Entrada NAO RECONHECIDA")
Example #8
0
def complemento(old):
    automato = Automato()
    ## percorre a lista e altera estados finais em normais
    for e in old.estados:
        if e.final:
            e.final = False
            automato.add_estado(e)
        else:
            e.final = True
            automato.add_estado(e)
    ## coloca as transições no novo automato
    automato.transicoes = old.transicoes
    return automato
Example #9
0
def determiniza(args):
    input = entrytext.get()
    l = Leitor(input)
    dict, ini, final = l.ler()
    a = Automato(dict,ini,final)
    a.determina()
    a.printAtomato()
    a.writeAutomataToFile(input)

    input = input.replace('.in', '')
    data_file = open('../testes/'+input+'.out')
    data = data_file.read()
    data_file.close()
    test = Tk.Tk()
    Results = Tk.Label(test, text = data, )
    Results.grid(row = 20, column = 3, sticky=(Tk.W, Tk.E))
Example #10
0
def init(arquivo):
    with open(arquivo) as arquivo:
        linhas, estados, alfabeto, inicial, finais = getInput(arquivo)

        automato = Automato(alfabeto, inicial, finais)

        aplicaTransicoes(linhas, estados)

        #Se o automato tiver todos os estados cadastrados, então o usuário poderá ler as palavras para teste
        if (verificaAutomato(estados, alfabeto) == False):
            res = input(
                "Selecione a opção dessejada digitando o número da respectiva opção:\n"
                + "1: Para testar palavras no autômato\n" +
                "2: Para mostrar estados equivalentes\n")

            if res == "1":
                lerPalavras(automato)
            elif res == "2":
                start(estados, automato)
Example #11
0
def uniaoOu(a1, a2, tag):
    novoAutomato = Automato(tag)  #Cria um novo automato
    #Adicionando todos os estados dos automatos antigos no novo
    estados1 = a1.getEstados()
    estados2 = a2.getEstados()
    for estado in estados1:
        novoAutomato.addEstado(estado)
    for estado in estados2:
        novoAutomato.addEstado(estado)
    #Criando novos estados
    novoInicial = Estado(True, False)
    novoFinal = Estado(False, True)
    novoAutomato.addEstado(novoInicial)
    novoAutomato.addEstado(novoFinal)
    novoAutomato.addEstadoInicial(novoInicial)
    novoAutomato.addEstadoFinal(novoFinal)
    #Criando novas transicoes para os estados iniciais
    iniciais1 = a1.getEstadosIniciais()
    iniciais2 = a2.getEstadosIniciais()
    for estado in iniciais1:
        t = Transicao(novoInicial, estado, '')
        novoInicial.addTransicao(t)
        estado.setInicial(False)
    for estado in iniciais2:
        t = Transicao(novoInicial, estado, '')
        novoInicial.addTransicao(t)
        estado.setInicial(False)
    #Criando novas transicoes para os estados finais
    finais1 = a1.getEstadosFinais()
    finais2 = a2.getEstadosFinais()
    for estado in finais1:
        t = Transicao(estado, novoFinal, '')
        estado.addTransicao(t)
        estado.setFinal(False)
    for estado in finais2:
        t = Transicao(estado, novoFinal, '')
        estado.addTransicao(t)
        estado.setFinal(False)
    novoAutomato.atualizaIds()
    return novoAutomato
class Lexico(object):

	#Delimitadores para transformar os varios em uma so transicao no automato
	def __init__(self, arq):
		self.reservadas = []
		self.delimitadores = []
		self.aut = Automato()
		self.arq = open(arq).readlines()
		self.linha_atual = 0
		self.col_atual = 0

	def insereEstado(self, est, final=False):
		self.aut.insereEstado(est, final)

	def insereTrans(self, est1, est2, simbolo):
		self.aut.insereTrans(est1, est2, simbolo)

	def setInicial(self, est):
		self.aut.setInicial(est)

	def insereDelimitador(self, dele):
		self.delimitadores.append(dele)

	def insereReservada(self, res):
		self.reservadas.append(res)

	#Retorna token se verdadeiro ou tupla com linha e coluna do erro, ex: ('ERRO', linha, coluna)
	def scanner(self):
		self.aut.resetInicial()
		token = ''

		#verifica se EOF
		if self.linha_atual == len(self.arq):
			return ('', 'EOF')

		#verifica se newline
		if self.arq[self.linha_atual][self.col_atual] == '\n':
			self.linha_atual += 1
			self.col_atual = 0
			return('newline', 'QL')

		#cria os tokens
		for i in range(self.col_atual, len(self.arq[self.linha_atual])):
			aux = self.arq[self.linha_atual][self.col_atual]
			if (aux in self.delimitadores and token != '') and not self.aut.hasTrans(self.aut.returnAtual(), aux):
				if self.aut.isFinal():
					if token in self.reservadas:
						return (token, token.upper())
					else:						
						return (token, self.aut.returnAtual())

				else:
					raise Exception('ERRO - Lexico, identificador invalido', self.linha_atual+1, self.col_atual+1)

			else:
				valid = True
				if aux not in self.delimitadores:
					valid = self.aut.hasTrans(self.aut.returnAtual(), aux)
					if valid:
						token += aux
						self.aut.doTrans(aux)

					if not valid:
						if self.aut.isFinal():
							if token in self.reservadas:
								return (token, token.upper())
							else:
								return (token, self.aut.returnAtual())
						else:
							raise Exception('ERRO - Lexico, estado nao eh final', self.linha_atual+1, self.col_atual+1)

				self.col_atual += 1

		#Entra somente no fim do arquivo
		self.linha_atual += 1
		if self.aut.isFinal():
			if token in self.reservadas:
				return (token, token.upper())
			else:
				return (token, self.aut.returnAtual())
		else:
			raise Exception('ERRO - Lexico, identificador invalido', self.linha_atual+1, self.col_atual+1)
def converteNFA(automato):
	estados = automato.estados.copy()
	finais = automato.finais.copy()
	inicio = automato.inicio
	n = 0
	masksE = {}
	etoi = {}
	itoe = {}

	for e in estados:
		etoi[e] = n
		itoe[n] = e
		n += 1

	for e in estados: masksE[e] = (1 << etoi[e])

	finalizado = False
	while not finalizado:
		finalizado = True

		for e in estados:
			for caractere, estado in estados[e]:
				if caractere == 'e':
					velha_mask = masksE[e]
					masksE[e] |= masksE[estado]
					finalizado = finalizado and (velha_mask == masksE[e])

	estadosF = {}
	finaisF = []
	inicioF = mask_to_str( (1 << etoi[inicio]) | masksE[inicio], n, itoe)

	for mask in range(1 << n):
		mask_str = mask_to_str(mask, n, itoe)
		transicoes = ''

		for estado in mask_str:
			for transicao in estados[estado]:
				if transicao[0] == 'e': continue
				if transicao[0] in transicoes: continue
				transicoes += transicao[0]

		for char in transicoes:
			goToMask = 0
			for i in range(n):
				if mask_possui_estado(mask, i):
					e = itoe[i]
					for caractere, novo_estado in estados[e]:
						if caractere == 'e' or len(novo_estado) > 1: continue
						if caractere == char:
							goToMask |= (1 << etoi[novo_estado])

			fo_to_mask_str = mask_to_str(goToMask, n, itoe)

			if mask_str not in estadosF: estadosF[mask_str] = []
			estadosF[mask_str].append( (char, fo_to_mask_str) )

		for est_final in finais:
			if est_final in mask_str:
				finaisF.append(mask_str)
				break

	return Automato(estadosF, finaisF, inicioF)
Example #14
0
import sys
from automato import Automato

if __name__ == "__main__":
    arquivo_automato, palavra_input = sys.argv[1], sys.argv[2]
    automato = Automato.ler_automato(arquivo_automato)
    automato.checar_pertencimento(palavra_input)
Example #15
0
    if len(input) > 1: input, palavra = input[0], input[1:] + palavra
    if (input == soma):
        print("<soma, {}>".format(input))
        proximo_estado = "Est1"
    elif (input == subtracao):
        print("<subtracao, {}>".format(input))
        proximo_estado = "Est1"
    elif (input == multiplicacao):
        print("<multiplicacao, {}>".format(input))
        proximo_estado = "Est1"
    elif (input == divisao):
        print("<divisao, {}>".format(input))
        proximo_estado = "Est1"
    elif len(input) == 0:
        proximo_estado = "err"
    else:
        proximo_estado = "Est_erro"
    return (proximo_estado, palavra)


if __name__ == "__main__":
    m = Automato()
    m.add_state("Est1", aceita_id)
    m.add_state("Est2", aceita_op, end_state=1)
    m.add_state("Est_erro", None, end_state=1)
    m.add_state("err", None, end_state=1)
    m.set_start("Est1")

    inpt = input("Insira a expressão a ser analizada: ")
    m.run(inpt)
Example #16
0
	def criar_automato(self):
		a = Automato()
		for terminal in self.tabela.x_rotulos:
			a.inserir_terminal(terminal)
		for estado in self.tabela.y_rotulos:
			a.inserir_estado(estado.lstrip('->*'))

		for i in range(self.tabela.n_linhas()):
			line = self.tabela.get_linha(i)
			atual = self.tabela.y_rotulos[i].lstrip('->*')
			for j in range(len(line)):
				terminal = self.tabela.x_rotulos[j]
				final = line[j]
				if final == '' or final == '-':
					continue
				for letra in final:
					if final == 'Qerr':
						break
					if letra not in ascii_uppercase:
						if letra not in ['@',',','&']:
							self.msg('Transicao para nao-estado detectada.', atual+' + '+terminal+' = '+final)
							return None
				#Verificar se "final" esta na lista de estados
				for item in final.split(','):
					if item not in a.estados and item != '@':
						self.msg('Transicao para um estado inexistente.', atual+' + '+terminal+' = '+final)
						return None
					a.inserir_transicao(atual, terminal, item)

		a.inserir_estado_inicial(self.tabela.inicial)
		for final in self.tabela.finais:
			a.inserir_estado_final( final )
		if self.tabela.finais == []:
			self.msg('O automato deve ter ao menos um estado final.')
			return None
		if self.tabela.inicial == '':
			self.msg('O automato deve ter um estado inicial.')
			return None				
		return a			
Example #17
0
# -*- coding: utf-8 -*-
import sys
from automato import Automato
from autDet import AutomatoDeterminizado
from autDetE import AutomatoDeterminizadoEpsilon

entrada = sys.argv[1]

# Abre o arquivo
f = open(entrada + ".in")
Input = f.read()
tabela = []
exec(Input)

#Inicializa o automato
aut = Automato()

# Adiciona estado inicial, considerando que o primeiro sempre sera inicial
aut.estadoInicial(tabela[1][1])

# Adiciona o conjunto de simbolos sigma
for i in range(1, len(tabela[0])):
    aut.adicionaSimbolo(tabela[0][i])

# Adiciona os estados presentes no automato e adiciona os estados finais
for i in range(1, len(tabela)):
    if tabela[i][0] == "*":
        aut.estadosFinais(tabela[i][1])
    aut.adicionaEstado(tabela[i][1])

#Adiciona a tabela do arquivo ao automato como tabela de transicao de estados
#-*- coding: utf-8 -*-

from modulo import Estado, Transicao
import modulo
from automato import Automato

if __name__ == '__main__':
    ## criando um novo automato
    a1 = Automato()

    ## Adicionando estados
    a1.add_estado(Estado(id=0, name='q0', initial=True))
    a1.add_estado(Estado(id=1, name='q1'))
    a1.add_estado(Estado(id=2, name='q2', final=True))

    ## Exibindo estados
    a1.print_estados()

    ## Adicionando transicoes
    a1.add_transicao(
        Transicao(de=a1.get_estado(name='q0'),
                  para=a1.get_estado(name='q1'),
                  ler='a'))
    a1.add_transicao(
        Transicao(de=a1.get_estado(name='q0'),
                  para=a1.get_estado(name='q0'),
                  ler='b'))
    a1.add_transicao(
        Transicao(de=a1.get_estado(name='q1'),
                  para=a1.get_estado(name='q2'),
                  ler='a'))
Example #19
0
def multiplicar(a1,a2):

    # novo automato
    new = Automato()

    # Alfabeto é a combinação dos simbolos dos dois
    new.alfabeto = set(a1.alfabeto+a2.alfabeto)
    
    ## concatenando os nomes
    for e1 in a1.estados:

        for e2 in a2.estados:
            ## novo estados
            new_id = str(e1.id) + str(e2.id)
            new_name = e1.name + e2.name

            ## se for estado inicial
            if e1.initial and e2.initial:
                new.add_estado(Estado(name=new_name,id=new_id,initial=True))

            ## se forem estados finais
            #elif e1.final or e2.final:
            #    new.add_estado(Estado(name=new_name,id=new_id,final=True))
            
            ## se não é normal    
            else: new.add_estado(Estado(name=new_name,id=new_id))

        ## fim for
    
    ## Outro for para fazer as transições, irá combinar leituras com os estados 
    for a in new.alfabeto:
        for e1 in a1.estados:
            for e2 in a2.estados:
                estado_de = new.get_estado(name=str(e1.name)+str(e2.name))
                estado_para = None
                p1 = a1.mover_name(e1.name,a)
                p2 = a2.mover_name(e2.name,a)
                ## se encontrar busca o estado
                if p1 and p2:
                    estado_para = new.get_estado(name=p1+p2)
                    ## cria tansicao
                    new.add_transicao( Transicao(de=estado_de,para=estado_para,ler=a) )
    return new
Example #20
0
def init():
    estados, inicial, aceita, transicoes, palavra, segundoArquivo = entrada()

    automato = Automato(estados, inicial, aceita, transicoes)
    if not "-" in palavra:
        automato.execultar(palavra)
    else:
        if palavra == "-uniao":
            estados, inicial, aceita, transicoes = parseEntrada(segundoArquivo)
            segundo_automato = Automato(estados, inicial, aceita, transicoes)
            automato.getUniao(segundo_automato)
        elif palavra == "-complemento":
            automato.getComplemento()
        elif palavra == "-estrela":
            automato.getEstrela()
        elif palavra == "-intercecao":
            automato.getIntercecao()
        elif palavra == "-complemento":
            automato.complemento()
        elif palavra == "-AFD":
            automato.getAFD()
        elif palavra == "-minimizacao":
            automato.getMinimizacao()
Example #21
0
def automatoSimples(simbolo, tag):
    automato = Automato(tag)  #Cria um novo automato
    eInicial = Estado(True, False)  #Cria um estado inicial
    eFinal = Estado(False, True)  #Cria um estado final
    #Adiciona os estados no automato
    automato.addEstado(eInicial)
    automato.addEstado(eFinal)
    automato.addEstadoInicial(eInicial)
    automato.addEstadoFinal(eFinal)
    transicao = Transicao(
        eInicial, eFinal,
        simbolo)  #Cria uma transicao entre o estado final e inicial
    eInicial.addTransicao(
        transicao
    )  #Adiciona a transicao na lista de transicoes do estado inicial
    automato.atualizaIds()
    return automato
Example #22
0
def uniaoE(a1, a2, tag):
    novoAutomato = Automato(tag)  #Cria um novo automato
    #Adicionando todos os estados dos automatos antigos no novo
    estados1 = a1.getEstados()
    estados2 = a2.getEstados()
    for estado in estados1:
        novoAutomato.addEstado(estado)
    for estado in estados2:
        novoAutomato.addEstado(estado)
    #Adicionando todos os estados iniciais de a1 como estados iniciais do novo automato
    for estado in a1.getEstadosIniciais():
        novoAutomato.addEstadoInicial(estado)
    #Fazendo todos os estados finais de a1 apontarem para os estados iniciais de a2
    for estadoFinal in a1.getEstadosFinais():
        estadoFinal.setFinal(False)
        for estadoInicial in a2.getEstadosIniciais():
            estadoInicial.setInicial(False)
            t = Transicao(estadoFinal, estadoInicial, '')
            estadoFinal.addTransicao(t)
    #Adicionando todos os estados finais de a2 na lista de estados finais do novo automato
    for estadoFinal in a2.getEstadosFinais():
        novoAutomato.addEstadoFinal(estadoFinal)
    novoAutomato.atualizaIds()
    return novoAutomato
Example #23
0
import json
from automato import Automato
from time import sleep
from lib.interface import menu, cabecalho

cabecalho(f'{"="*20} Pytomatos {"="*20}')

while True:
    automato = Automato('automato.json')

    resposta = menu(
        ['Imprimir detalhes do autômato', 'Testar palavra', 'Sair do sistema'])

    if resposta == 1:
        print()
        cabecalho('Opção 1 - Imprimir detalhes do autômato')
        if automato.tipo == 'afn':
            print(automato)
            sleep(1)
            print('Convertendo o autômato para AFD...')
            print()
            automato.converter_afn_afd()
            sleep(1)
            print(f'Autômato convertido: \n{automato}')
        else:
            print(automato)
        sleep(1)

    elif resposta == 2:
        print()
        cabecalho('Opção 2 - Testar palavra')
Example #24
0
	def inicia(self):
		case = 0
		lex = Lex()

		# # 1 ER PALAVRAS RESERVADAS
		a1 = lex.lexer('reservado', case)
		dict = a1.getDictAutomato()
		case += len(dict)

		# # 2 ER IDENTIFICADORES
		a2 = lex.lexer('identificadores', case)

		# # 3 GRAMATICA DE SESPECIAL
		terminais = ['+', '-', '=', '/', '*', '>', '<', '!']
		nTerminais = ['S']
		producoes = {'S': ['+', '-', '=', '/', '*', '>', '<', '!']}
		inicial = 'S'
		g = Grammar(producoes,terminais, nTerminais, inicial)
		s, i, f = g.convertGtoAF()
		a3 = Automato(s, i, f)
		a3.determina()
		a3.printAtomato()
		print("\n")

		dict = a2.getDictAutomato()
		case += len(dict)
		a3 = lex.renameState(a3, case)

		# # 4 GRAMATICA SEPARADORES
		terminais2 = [':',';', ' ', '(', ')', '[', ']', ',', '\n']
		nTerminais2 = ['S']
		producoes2 = {'S': [':',';', ' ', '(', ')', '[', ']', ',', '\n']}
		inicial2 = 'S'
		g = Grammar(producoes2,terminais2, nTerminais2, inicial2)
		s2, i2, f2 = g.convertGtoAF()
		a4 = Automato(s2, i2, f2)
		a4.determina()
		a4.printAtomato()
		print("\n")

		dict = a3.getDictAutomato()
		case += len(dict)
		a4 = lex.renameState(a4, case)

		# ER CONSTANTES
		dict = a4.getDictAutomato()
		case += len(dict)
		a5 = lex.lexer('constantes', case)
		r = a5

		r = a1.oU([a2, a3, a4, a5])
		print ("\n")
		r.determina()
		r.printAtomato()

		with open('automato.pkl', 'wb') as output:
		    pickle.dump(r, output, pickle.HIGHEST_PROTOCOL)
Example #25
0
import sys
from automato import Automato

if __name__ == "__main__":
    arquivo_automato1, arquivo_automato2 = sys.argv[1], sys.argv[2]
    automato1 = Automato.ler_automato(arquivo_automato1)
    automato2 = Automato.ler_automato(arquivo_automato2)
    automato_uniao = automato1.uniao(automato2)
    print(automato_uniao)