Proyecto de Compilador

INTEGRANTES:

* Karim Ghonem Camacho

* David Hurtado
* Oscar Claros

DOCENTE: ING. EGUEZ, CARLOS

GRUPO: A

MATERIA: COMPILADORES

Santa Cruz, Bolivia

2019
 Analizador Léxico
Componentes Teóricos
Objetivo
Realizar la primera fase de un compilador, un analizador léxico.

Programas
Fuente – Matlab

Construcción -

Objeto – Python

Expresiones Regulares
 Tokens
'IDENTIFICADOR',
'SIGNO',
'NUMERO',
'CADENA',

 Palabras Reservadas
'if': 'IF',
'while': 'WHILE',
'else': 'ELSE',
'int': 'INT',
'for': 'FOR',
'end': 'END',

 Signos
'+': 'SUMA',
'-': 'RESTA',
'*': 'MULTIPLICADOR',
'/': 'DIVISON',
'=': 'IGUAL',
';': 'PUNTOCOMA',
':': 'DOSPUNTOS',
'(': 'PARIZQ',
')': 'PARDER',

Definiciones
Numero

Identificador

Cadena

Signo
Nueva Línea

Error

Componentes
Tabla de Símbolos
Operad
Significado
or
+ Suma
- Resta
Multiplicaci
*
ón
/ División
= Igualdad
Punto
;
Coma
: Dos Puntos
Par
(
Izquierdo
Par
)
Derecho

Codigo
import ply.lex as lex

# Resultado del analisis

resultado_lexema = []

# Listas para tokens

palabras_reservadas = {
'if': 'IF',
'while': 'WHILE',
'else': 'ELSE',
'int': 'INT',
'for': 'FOR',
'end': 'END',
}

signo = {
'+': 'SUMA',
'-': 'RESTA',
'*': 'MULTIPLICADOR',
'/': 'DIVISON',
'=': 'IGUAL',
';': 'PUNTOCOMA',
':': 'DOSPUNTOS',
'(': 'PARIZQ',
')': 'PARDER',
}

tokens = [
'IDENTIFICADOR',
'SIGNO',
'NUMERO',
'CADENA',
] + list(palabras_reservadas.values()) + list(signo.values())

def t_NUMERO(t):
r'\d+'
t.value = int(t.value)
return t

def t_IDENTIFICADOR(t):
r'\w+(_\d\w)*'
t.type = palabras_reservadas.get(t.value, 'IDENTIFICADOR')
return t

def t_CADENA(t):
r'\"?(\w+ \ *\w*\d* \ *)\"?'
return t

def t_SIGNO(t):
r'[+-/*=;:()]'
t.type = signo.get(t.value,'SIGNO')
return t

def t_newline(t):
r'\n+'
t.lexer.lineno += len(t.value)

def t_error(t):
global resultado_lexema
estado = "** Token no valido en la Linea {:4} Valor {:16} Posicion
{:4}".format(str(t.lineno), str(t.value),
str(t.lexpos))
resultado_lexema.append(estado)
t.lexer.skip(1)

# Prueba de ingreso
def prueba(data):
global resultado_lexema

analizador = lex.lex()
analizador.input(data)

resultado_lexema[:] = []
while True:
tok = analizador.token()
if not tok:
break

estado = "Tipo {:16} Valor {:16}".format(str(tok.type), str(tok.value))

print(estado)
 return resultado_lexema

# Instanciamiento del Analizador

analizador = lex.lex()

if __name__ == '__main__':
codigo = open('prueba.txt', 'r')

codigo = codigo.read()

my_list = codigo.splitlines()

for line in my_list:

data = line
prueba(data)

Avance gramático de Matlab

Tabla de regla gramática:
1. PM  DefFuncion
2. PM  SeqSentencias
3. PM DefFuncion SeqSentencias
4. DefFuncion funcion ID SeqSentecncias End
5. DefFuncion funcion ID( SeqParametros) SeqSentecncias End
6. SeqParametros ID
7. SeqParametros ID SeqParametros
8. SeqSentecncias Sentencia
9. SeqSentecncias Sentencia SeqSentecncias
10. DefFor for ID=Valor: Valor: Valor SeqSentencias end
11. Valor ConstanteEnum
12. Valor ID
13. Sentencia  DefFor
14. Sentencia  Asignacion
15. Sentencia  LlamadaFuncion
16. Sentencia  Cond
17. Asignacion ID= Valor
18. AsignacionID=LlamadaFuncion
19. Asignacion ID=exp
20. LlamadaFuncion ID
21. LlamadaFuncionID(SeqParametrosLlamadas)
22. SeqParametrosLlamadas Valor
23. SeqParametrosLlamadas Valor, SeqParametrosLlamadas
24. Exp Operando restoexp
25. restoexp operador exp
26. restoexp operador operando
27. Operando Valor
28. Operando LlamadaFuncion
 29. Cond if excond SeqSentencias else SeqSentencias end
30. Cond if excond seqSentencias elseif excond seqSentencias end
31. Cond  if excond seqSentencias elseif excond SeqSentencias else seqSentencias end
32. Excond  (operando oplog operando)
33. Excond  (operando oplog operando) oplog Excond
34. Operando  (operando)
35. Operando  (operando oplog operando )
36. Operando  (operando)
37. Operando  operando oplog operando
38. Oplog  &&
39. Oplog  ||
40. Oplog  &
41. Oplog  |
42. Oplog  ~
43. Oplog  and
44. Oplog  or
45. Oplog  not
46. Oplog  <
47. Oplog  =<
48. Oplog  >
49. Oplog  >=
50. Oplog  ==
51. Oplog  ~=
52. Operador  +
53. Operador  -
54. Operador  *
55. Operador  /
56. Operador  plus
57. Operador  minus
58. Operador  multiply
59. Operador  divide
60. Operador  power

Descripción de las etapas del proceso de compilación

Análisis léxico. Consiste en agrupar caracteres para formar las unidades que ya tienen

significado por si mismas (tokens).

NOTA. Token es la moneda de menor valor.

Análisis sintáctico. Se analizan las sentencias, que están compuestas de tokens, de

acuerdo con la sintaxis del lenguaje.

Análisis semántico y Generador de código intermedio son dos etapas que se

representan juntas porque la generación de código intermedio utiliza el mismo árbol del

análisis semántico.

Optimización del código. Es una sección optativa pero muy difundida y demandada

entre los compiladores profesionales. Por ello, Los constructores de compiladores gastan

mucho dinero en ella. Trata de optimizar el código en tamaño y/o velocidad.

Generador de código final. Se encarga de generar el código en el lenguaje objeto del

compilador.

NOTA. Los objetos del programa pueden ser simples (enteros, reales) o complejos (matrices, registros,
funciones,

procedimientos). Tienen un identificador asociado, una posición en memoria, un valor y unos atributos.
El valor es el

almacenado en la zona de memoria que ocupa el objeto y los atributos determinan los valores que
puede tomar el

objeto, las operaciones a las que se puede someter...

Las tablas de símbolos tienen al menos la siguiente información respecto de cada objeto del programa.
Su nombre o denotador, Los atributos (el más importante es el tipo), Su posición en memoria o la forma
de encontrarla...

El gestor de errores trata de optimizar las compilaciones de un programa. El gestor

Divide el código por tramos delimitados por marcas de bloque (begin y end en Pascal).

Si en un tramo de código encuentra demasiados errores (entra en modo panic) lo ignora y pasa a
compilar el siguiente tramo. En consecuencia, cuando el compilador nos indica los errores que ve
tenemos que ser conscientes de que son consecuencia de las partes compiladas y de las no compiladas.
Descripción de los autómatas finito para que sea determinístico
Un autómata finito (AF) o máquina de estado finito es un modelo computacional que realiza cómputos
en forma automática sobre una entrada para producir una salida. Este modelo está conformado por un
alfabeto, un conjunto de estados finito, una función de transición, un estado inicial y un conjunto de
estados finales. Su funcionamiento se basa en una función de transición, que recibe a partir de un
estado inicial una cadena de caracteres pertenecientes al alfabeto (la entrada), y que va leyendo dicha
cadena a medida que el autómata se desplaza de un estado a otro, para finalmente detenerse en un
estado final o de aceptación, que representa la salida. La finalidad de los autómatas finitos es la de
reconocer lenguajes regulares, que corresponden a los lenguajes formales más simples según la
Jerarquía de Chomsky.
Un autómata finito determinista (abreviado AFD) es un autómata finito que además es un sistema
determinista; es decir, para cada estado en que se encuentre el autómata, y con cualquier símbolo del
alfabeto leído, existe siempre no más de una transición posible desde ese estado y con ese símbolo.

Formalmente, se define como una 5-tupla (Q, Σ, q0, δ, F) donde:

Q es un conjunto de estados;

∑ es un alfabeto;

q_0∈Q es el estado inicial;

δ:Q ×∑→Q es una función de transición;

F⊆Q es un conjunto de estados finales o de aceptación.

En un AFD no pueden darse ninguno de estos dos casos:

Que existan dos transiciones del tipo δ(q,a)=q1 y δ(q,a)=q2, siendo q1 ≠ q2;

Que existan transiciones del tipo δ(q, ε), donde ε es la cadena vacía, salvo que q sea un estado
final, sin transiciones hacia otros estados.