lexer_parser/parser.py at main · francohilt/lexer_parser · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
from GrupoAceptado_TP1_V5 import lex

Terminales = [
	"puntoYComa",
	"dosPuntosIgual",
	"si",
	"entonces",
	"sino",
	"mientras",
	"hacer",
	"op",
	"corcheteAbierto",
	"corcheteCerrado",
	"parentesisAbierto",
	"parentesisCerrado",
	"aceptar",
	"mostrar",
	"coma",
	"literal",
	]

NoTerminales = [
	'PROGRAMA',
	'DECLARACION',
	'DECLARACION2',
	'SENTENCIA',
	'SENTENCIA2',
	'EXPRESION',
	'EXPRESION2',
	'LISTAIDENTIFICADORES',
	]

#Eliminamos la recursion por la izquierda inmediata
Producciones = {
	'PROGRAMA' : [
		['DECLARACION', 'puntoYComa', 'SENTENCIA'],
		['SENTENCIA'],
	],

 	'DECLARACION' : [
		['SENTENCIA','DECLARACION2'],
	],

	'DECLARACION2' : [
		['puntoYComa','DECLARACION','DECLARACION2'],
		[],
	],

	'SENTENCIA': [
		['si','EXPRESION','entonces','SENTENCIA','sino','SENTENCIA','SENTENCIA2'],
		['si','EXPRESION','entonces','SENTENCIA', 'SENTENCIA2'],
		['mientras', 'EXPRESION','hacer','SENTENCIA','SENTENCIA2'],
		['literal', 'dosPuntosIgual', 'EXPRESION', 'SENTENCIA2'],
	],

	'SENTENCIA2' : [
		['puntoYComa','SENTENCIA','SENTENCIA2'],
		[],
	],

	'EXPRESION': [
		['aceptar','literal','op','EXPRESION2'],
		['mostrar','literal','LISTAIDENTIFICADORES','EXPRESION2'],
		['op','EXPRESION2'],
		['literal','EXPRESION2'],
	],

	'EXPRESION2': [
		['op','EXPRESION','EXPRESION2'],
		['corcheteAbierto','EXPRESION','corcheteCerrado','EXPRESION2'],
		['parentesisAbierto','EXPRESION','parentesisCerrado','EXPRESION2'],
		[],
	],

	'LISTAIDENTIFICADORES': [
		['op'],
		['op','coma','LISTAIDENTIFICADORES'],
	]
}

def parser(cadena):
	estado = {
		'error' : False ,
		'tokens' : lex(cadena),
		'index' : 0
	}

	def pni(noTerminal): #Expande el no terminal por cada una de las formas de reescribirlo.

		for produccion in Producciones[noTerminal]:
			pivote_de_backtracking = estado['index']
		#	print(estado['index'])
			estado['error'] = False
			procesar(produccion)
			if estado['error'] == False:
				break
			if estado['error'] == True:
				estado['index'] = pivote_de_backtracking

	def procesar(parteDerecha):
		for simbolo in parteDerecha:

			if simbolo in Terminales:
			#tomo el tipo de token (primer elemento de la tupla), ubicado en la lista de tokens, determinado por el indice.

				if simbolo == estado['tokens'][estado['index']][0]:
					estado['index'] += 1
				#print("------------------>   aceptó", simbolo)
				else:
					estado['error'] = True
					break
			if simbolo in NoTerminales:
				pni(simbolo)
				if estado['error'] == True:
					break

	def parse(): #Si no hubo error y se llegó al final de la cadena podemos asegurar que pertenece al lenguaje generado por la gramática.
		pni('PROGRAMA')
		token_actual = estado['tokens'][estado['index']]
		tipo_token_actual = token_actual[0]
		if estado['error'] == False and tipo_token_actual == 'EOF':
			return True
		else:
			return False

	return parse()

print('--------------------------------------------------------------------------------------------------------------------------------------------')

casos_de_prueba = [ ("si 100 > numero entonces value1 := False",True),
					("var := ventas + bonus",True),
					("mayor := numero1 > numero2",True),
					("mientras longitud < 7 hacer senial := 1",True),
					("si cantAlumnos > 50 entonces aula := magna sino aula := aula1",True),
					("(x : xs)",False),
					("numeros  1000 + 0.5 ",False),
					("SINO SI 'Eve' 'Romi' == ACEPTAR 'Nanu' Fran",False),
					("hoy const = 2 mientras",False),
					("sino 527 ('cama' ('gaseosa')) puff Campana := 07",False)
					]

for (test_input,resultado_esperado) in casos_de_prueba:
    resultado = parser(test_input)
    assert resultado == resultado_esperado