DOCUMENTACION ANALISIS SINTACTICO.pdf
-
Upload
david-valverde -
Category
Documents
-
view
23 -
download
1
Transcript of DOCUMENTACION ANALISIS SINTACTICO.pdf
PROYECTO DE CATEDRA COMPILADORES
Presentado por: Daniel Salgado Para : Ing. Julio Cesar Sierra
Juan Carlos Rojas
Analizador Sintáctico
Sea la Gramática:
1. programa -> program id (lista_identificadores) ; declaraciones lista_proposiciones .
2. lista_identificadores –> id | lista_identificadores , id
3. declaraciones -> declaraciones var lista_identificadores : tipo; | ε
4. tipo -> tipo_estandar | array [num .. num] of tipo_estandar
5. tipo_estandar -> int | real
6. lista_proposiciones -> proposicion | lista_proposiciones ; proposicion
7. proposicion -> id = expresion | if expresión then proposicion else proposicion
8. expresion -> factor oprel expresion | factor
9. factor -> id | num | (expresion)
10. oprel -> > | < | ==
CONVENCIONES
declaraciones D
expresion E
factor F
lista_identificadores N
lista_proposiciones L
oprel O
programa A
proposicion S
tipo T
tipo_estandar R
Gramática reescrita:
1. A-> program id ( N ) ; D L .
2. N -> id | N , id
3. D –>D var N : T; | ε
4. T ->R | array [num .. num] of R
5. R -> int | real
6. L -> S | L ; S
7. S -> id = E | if E then S else S
8. E -> F O E | F
9. F -> id | num | ( E )
10. O -> > | < | ==
I- ELIMINACION DE AMBIGÜEDAD
Si A -> αβ1 | αβ2 | … | αβn | φ
Ent A = αA’ | φ
A’ = β1 | β2 | … | βn
8. E -> F O E | F
A = E
α = F
β1 = OE
β2 = ε
E -> FE’
E’ -> OE | ε
Gramática sin ambigüedad:
1. A -> program id ( N ) ; D L .
2. N -> id | N , id
3. D -> D var N : T ; | ε
4. T -> R | array [num .. num] of R
5. R -> int | real
6. L -> S | L ; S
7. S -> id = E | if E then S else S
8. E -> FE’
9. E’ -> OE | ε
10. F -> id | num | ( E )
11. O -> > | < | ==
II - ELIMINACION DE RECURSION POR LA IZQUIERDA
Si A -> Aα1 | Aα2 | … | Aαn | β1 | β2 | … | βm
Ent A -> β1A’ | β2A’ | … | βmA’
A’ -> α1A’ | α2A’ | … | αnA’ | ε
2. N -> id | N , id
A = N
α1 = , id
β1 = id
N -> id N’
N’ -> , id N’ | ε
3. D -> D var N : T ; | ε
α1 = var N : T ;
β1 = ε
D-> D’
D’ -> var N : T ; D’ | ε
6. L -> S | L ; S
A = L
α1 = ; S
L -> S L’
L’ -> ; S L’ | ε
Gramática sin recursión por la izquierda:
1. A -> program id ( N ) ; D L .
2. N -> id N’
3. N’ -> , id N’| ε
4. D -> D’
5. D’ -> var N : T ; D’ | ε
6. T -> R | array [num .. num] of R
7. R -> int | real
8. L -> S L’
9. L’ -> ; S L’ | ε
10. S -> id = E | if E then S else S
11. E -> FE’
12. E’ -> OE | ε
13. F -> id | num | ( E )
14. O -> > | < | ==
1. programa -> program id (lista_identificadores) ; declaraciones lista_proposiciones .
2. lista_identificadores -> id lista_identificadores’
3. lista_identificadores’ -> , id lista_identificadores’ | ε
4. declaraciones -> declaraciones’
5. declaraciones’ -> var lista_identificadores : tipo ; declaraciones’ | ε
6. tipo -> tipo_estandar | array [num .. num] of tipo_estandar
7. tipo_estandar -> int | real
8. lista_proposiciones -> proposicion lista_proposiciones’
9. lista_proposiciones’ -> ; proposicion lista_proposiciones’ | ε
10. proposicion -> id = expresion | if expresion then proposicion else proposicion
11. expresion -> factor expresion’
12. expresion’ -> oprel expresion | ε
13. factor -> id | num | (expresion )
14. oprel > > | < | ==
III- CONJUNTOS PRIMERO
1. A -> program id ( N ) ; D L .
Prim (A) = {Prim(program), … }
Prim(program) = {program} no contiene ε
Prim(A) = {program}
2. N -> id N’
Prim (N) = {Prim(id), … }
Prim(id) = {id} no contiene ε
Prim(N) = {id}
3. N’ -> , id N’| ε
Prim(N’) = {Prim(,), ….} U {Prim(ε)}
Prim(,) = { , } no contiene ε
Prim(ε) = { ε }
Prim(N’) = {, , ε }
4. D -> D’
Prim(D) = {var, ε }
5. D’ -> var N : T ; D’ | ε
Prim(D’) = {Prim(var), …} U {Prim(ε)}
Prim(var) = {var} no contiene ε
Prim(ε) = { ε }
Prim(D’) = {var, ε}
6. T -> R | array [num .. num] of R
Prim(T)= {Prim(R)} U {Prim(array …}
Prim(R) = {int, real}
Prim(array) = {array} no contiene ε
Prim(T) = {int, real, array}
7. R -> int | real
Prim(R) = {Prim(int)} U {Prim(real)}
Prim(int) = {int}
Prim(real)={real}
Prim(R) = {int, real}
8. L -> S L’
Prim(L) = {Prim(S), Prim(L’)}
Prim(S) = {id, if} no contiene ε
Prim(L) = {id, if}
9. L’ -> ; S L’ | ε
Prim(L’) = {Prim(;), …} U {Prim(ε)}
Prim(;) = {;} no contiene ε
Prim(ε) = {ε}
Prim(L’) = { ;, ε }
10. S -> id = E | if E then S else S
Prim(S) = {Prim(id), …} U {Prim(if), …}
Prim(id)= {id} no contiene ε
Prim(if) = {if} no contiene ε
Prim(S) = {id, if}
11. E -> FE’
Prim(E) = {Prim(F), Prim(E’)}
Prim(F) = {id, num, (} no contiene ε
Prim(E) = {id, num, (}
12. E’ -> OE | ε
Prim(E’) = {Prim(O), Prim(E)} U {Prim(ε)}
Prim(O) = {>, <, =} no contiene ε
Prim(E’) = {>, <, =, ε }
13. F -> id | num | ( E )
Prim(F) = {Prim(id)} U {Prim(num)} U {Prim(()}
Prim(F) = {id, num, (}
14. O -> > | < | ==
Prim(O) = {Prim(>)} U {Prim(<)} U {Prim(=)}
Prim(O) = {>, <, =}
Conjuntos Primero
Prim(A) = { program }
Prim(N) = { id }
Prim(N’) = { ,, ε }
Prim(D) = { var, ε }
Prim(D’) = { var, ε}
Prim(T) = { int, real, array }
Prim(R) = { int, real }
Prim(L) = { id, if }
Prim(L’) = { ;, ε }
Prim(S) = { id, if }
Prim(E) = { id, num, ( }
Prim(E’) = { >, <, =, ε }
Prim(F) = { id, num, ( }
Prim(O) = { >, <, = }
Prim(programa) = { program }
Prim(lista_identificadores) = { id }
Prim(lista_identificadores’) = { ,, ε }
Prim(declaraciones) = { var, ε }
Prim(declaraciones’) = { var, ε }
Prim(tipo) = { int, real, array }
Prim(tipo_estandar) = { int, real }
Prim(lista_proposiciones) = { id, if }
Prim(lista_proposiciones’) = { ;, ε }
Prim(proposicion) = { id, if }
Prim(expresion) = { id, num, ( }
Prim(expresion’) = { >, <, =, ε }
Prim(factor) = { id, num, ( }
Prim(oprel) = { >, <, = }
IV- CONJUNTOS SIGUIENTE
Sig(A) = {$}
Sig(N) = { }
Sig(N’) = { }
Sig(D) = { }
Sig(D’) = { }
Sig(T) = { }
Sig(R) = { }
Sig(L) = { }
Sig(L’) = { }
Sig(S) = { }
Sig(E) = { }
Sig(E’) = { }
Sig(F) = { }
Sig(O) = { }
1. A -> program id ( N ) ; D L .
A -> X1X2X3X4X5X6X7X8X9
Para i=1 X1 = program es token. Luego no aplica.
Para i=2 X2 = id es token. Luego no aplica.
Para i=3 X3 = ( es token. Luego no aplica.
Para i=4 X4 = N
Agregar Prim();DL.) - ε a Sig(N)
Agregar { ) } a Sig(N)
Para i=5 X5 = ) es token. Luego no aplica.
Para i=6 X6 = ; es token. Luego no aplica.
Para i=7 X7 = D
Agregar Prim(L) - ε a Sig(D)
Agregar {id, if} - ε a Sig(D)
Para i=8 X8 = L
Agregar Prim( .) - ε a Sig(L)
Agregar { . } a Sig(L)
Para i=9 X9 = . es token. Luego no aplica.
2. N -> id N’
A -> X1X2
Para i=1 X1 = id es token. Luego no aplica.
Para i=2 X2 = N’
Agregar Sig(N) a Sig(N’)
3. N’ -> , id N’| ε
A -> X1X2X3
Para i=1 X1 = , es token. Luego no aplica.
Para i=2 X2 = id es token. Luego no aplica.
Para i=3 X3 = N’
Agregar Sig(N’) a Sig(N’)
4. D -> D’
A -> X1
Para i=1 X1 = D’
Agregar Sig(D) a Sig(D’)
5. D’ -> var N : T ; D’ | ε
A -> X1X2X3X4X5X6
Para i=1 X1 = var es token. Luego no aplica.
Para i=2 X2 = N
Agregar Prim(: T ; D’) - ε a Sig(N)
Agregar {:} a Sig(N)
Para i=3 X3 = : es token. Luego no aplica.
Para i=4 X4 = T
Agregar Prim(; D’) - ε a Sig(T)
Agregar {;} a Sig(T)
Para i=5 X5 = ; es token. Luego no aplica.
Para i=6 X4 = D’
Agregar Sig(D’) a Sig(D’)
6. T -> R | array [num .. num] of R
T -> R
A -> X1
Para i=1 X1 = R
Agregar Sig(T) a Sig(R)
T -> array [num .. num] of R
A -> X1X2X3X4X5X6X7X8
Para i=1 X1 = array es token. Luego no aplica.
Para i=2 X2 = [ es token. Luego no aplica.
Para i=3 X3 = num es token. Luego no aplica.
Para i=4 X4 = .. es token. Luego no aplica.
Para i=5 X5 = num es token. Luego no aplica.
Para i=6 X6 = ] es token. Luego no aplica.
Para i=7 X7 = of es token. Luego no aplica.
Para i=8 X8 = R
Agregar Sig(T) a Sig(R)
7. R -> int | real
Solo tokens. No aplica
8. L -> S L’
A -> X1X2
Para i=1 X1 = S
Agregar Prim(L’) - ε a Sig(S)
Agregar {;, ε } – ε a Sig(S)
Agregar Sig(L) a Sig(S)
Para i=2 X2 = L’
Agregar Sig(L) a Sig(L’)
9. L’ -> ; S L’ | ε
A -> X1X2X3
Para i=1 X1 = ; es token. Luego no aplica.
Para i=2 X2 = S
Agregar Prim(L’) - ε a Sig(S)
Agregar {;, ε } – ε a Sig(S)
Agregar Sig(L’) a Sig(S)
Para i=3 X3 = L’
Agregar Sig(L’) a Sig(L’)
10. S -> id = E | if E then S else S
S -> id = E
A -> X1X2X3
Para i=1 X1 = id es token. Luego no aplica.
Para i=2 X2 = = es token. Luego no aplica.
Para i=3 X3 = E
Agregar Sig(S) a Sig(E)
S -> if E then S else S
A -> X1X2X3X4X5X6
Para i=1 X1 = if es token. Luego no aplica.
Para i=2 X2 = E
Agregar Prim(then S else S) - ε a Sig(E)
Agregar {then} a Sig(E)
Para i=3 X3 = then es token. Luego no aplica.
Para i=4 X4 = S
Agregar Prim(else S) - ε a Sig(S)
Agregar {else} a Sig(S)
Para i=5 X5 = else es token. Luego no aplica.
Para i=6 X6 = S
Agregar Sig(S) a Sig(S)
11. E -> FE’
A -> X1X2
Para i=1 X1 = F
Agregar Prim(E’) - ε a Sig(F)
Agregar {>, <, =, ε} - ε a Sig(F)
Agregar Sig(E) a Sig(F)
Para i=2 X2 = E’
Agregar Sig(E) a Sig(E’)
12. E’ -> OE | ε
A -> X1X2
Para i=1 X1 = O
Agregar Prim(E) - ε a Sig(O)
Agregar {id, num, (} a Sig(O)
Para i=2 X2 = E
Agregar Sig(E’) a Sig(E)
13. F -> id | num | ( E )
F -> id | num
Solo tokens. No aplica
F -> (E)
A -> X1X2X3
Para i=1 X1 = ( es token. Luego no aplica.
Para i=2 X2 = E
Agregar Prim()) - ε a Sig(E)
Agregar {)} a Sig(E)
Para i=3 X3 = ) es token. Luego no aplica.
14. O -> > | < | ==
Solo tokens. No aplica
Conjuntos Siguiente
Sig(A) = { $ }
Sig(N) = { ), : }
Sig(N’) = { ), : }
Sig(D) = { id, if }
Sig(D’) = { id, if }
Sig(T) = { ; }
Sig(R) = { ; }
Sig(L) = { . }
Sig(L’) = { . }
Sig(S) = { ;, ., else }
Sig(E) = { ;, .,then, else, ) }
Sig(E’) = { ;, .,then, else, ) }
Sig(F) = { ;, .,then, else, ), >, <, = }
Sig(O) = { id, num, ( }
Sig(programa) = { $ }
Sig(lista_identificadores) = { ), : }
Sig(lista_identificadores’) = { ), : }
Sig(declaraciones) = { id, if }
Sig(declaraciones’) = { id, if }
Sig(tipo) = { ; }
Sig(tipo_estandar) = { ; }
Sig(lista_proposiciones) = { . }
Sig(lista_proposiciones’) = { . }
Sig(proposicion) = { ;, ., else }
Sig(expresion) = { ;, .,then, else, ) }
Sig(expresion’) = { ;, .,then, else, ) }
Sig(factor) = { ;, .,then, else, ), >, <, = }
Sig(oprel) = { id, num, ( }
1. Empezamos la construcción de la tabla M, analizando cada producción de la forma A -> µ : A -> program id ( N ) ; D L .
--------------------------------
µ
Paso 2 :
El PRIMERO de ( program id ( N ) ; D L . ) es = { program }.
Agregamos en la tabla M, las entradas :
M[A,program] = A -> program id ( N ) ; D L .
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
N -> id N'
------
µ
Paso 2 :
El PRIMERO de ( id N' ) es = { id }.
Agregamos en la tabla M, las entradas :
M[N,id] = N -> id N'
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
N' -> , id N'
---------
µ
Paso 2 :
El PRIMERO de ( , id N' ) es = { , }.
Agregamos en la tabla M, las entradas :
M[N',,] = N' -> , id N'
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
N' -> £
-
µ
Paso 2 :
El PRIMERO de ( £ ) es = { £ }.
NO agregamos entrada a la tabla M, ya que el £ no es columna de la tabla.
El paso 2 NO aplica.
Paso 3 :
El PRIMERO de ( µ ) SI contiene al £, así que agregamos las entradas a la
tabla M, para cada terminal en el SIGUIENTE( N' ) = { ) : }
M[N',)] = N' -> £
M[N',:] = N' -> £
═════════════════════════════════════════════════════════════
══════════════
D -> D'
-----
µ
Paso 2 :
El PRIMERO de ( D' ) es = { £ var }.
NO agregamos entrada a la tabla M, ya que el £ no es columna de la tabla.
El paso 2 NO aplica.
Paso 3 :
El PRIMERO de ( µ ) SI contiene al £, así que agregamos las entradas a la
tabla M, para cada terminal en el SIGUIENTE( D ) = { id if }
M[D,id] = D -> D'
M[D,if] = D -> D'
═════════════════════════════════════════════════════════════
══════════════
D' -> var N : T ; D'
-------------------
µ
Paso 2 :
El PRIMERO de ( var N : T ; D' ) es = { var }.
Agregamos en la tabla M, las entradas :
M[D',var] = D' -> var N : T ; D'
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
D' -> £
-
µ
Paso 2 :
El PRIMERO de ( £ ) es = { £ }.
NO agregamos entrada a la tabla M, ya que el £ no es columna de la tabla.
El paso 2 NO aplica.
Paso 3 :
El PRIMERO de ( µ ) SI contiene al £, así que agregamos las entradas a la
tabla M, para cada terminal en el SIGUIENTE( D' ) = { id if }
M[D',id] = D' -> £
M[D',if] = D' -> £
═════════════════════════════════════════════════════════════
══════════════
T -> R
-
µ
Paso 2 :
El PRIMERO de ( R ) es = { int real }.
Agregamos en la tabla M, las entradas :
M[T,int] = T -> R
M[T,real] = T -> R
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
T -> array [ num .. num ] of R
--------------------------------
µ
Paso 2 :
El PRIMERO de ( array [ num .. num ] of R ) es = { array }.
Agregamos en la tabla M, las entradas :
M[T,array] = T -> array [ num .. num ] of R
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
R -> int
---
µ
Paso 2 :
El PRIMERO de ( int ) es = { int }.
Agregamos en la tabla M, las entradas :
M[R,int] = R -> int
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
R -> real
----
µ
Paso 2 :
El PRIMERO de ( real ) es = { real }.
Agregamos en la tabla M, las entradas :
M[R,real] = R -> real
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
L -> S L'
-----
µ
Paso 2 :
El PRIMERO de ( S L' ) es = { id if }.
Agregamos en la tabla M, las entradas :
M[L,id] = L -> S L'
M[L,if] = L -> S L'
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
L' -> ; S L'
--------
µ
Paso 2 :
El PRIMERO de ( ; S L' ) es = { ; }.
Agregamos en la tabla M, las entradas :
M[L',;] = L' -> ; S L'
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
L' -> £
-
µ
Paso 2 :
El PRIMERO de ( £ ) es = { £ }.
NO agregamos entrada a la tabla M, ya que el £ no es columna de la tabla.
El paso 2 NO aplica.
Paso 3 :
El PRIMERO de ( µ ) SI contiene al £, así que agregamos las entradas a la
tabla M, para cada terminal en el SIGUIENTE( L' ) = { . }
M[L',.] = L' -> £
═════════════════════════════════════════════════════════════
══════════════
S -> id = E
--------
µ
Paso 2 :
El PRIMERO de ( id = E ) es = { id }.
Agregamos en la tabla M, las entradas :
M[S,id] = S -> id = E
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
S -> if E then S else S
-----------------------
µ
Paso 2 :
El PRIMERO de ( if E then S else S ) es = { if }.
Agregamos en la tabla M, las entradas :
M[S,if] = S -> if E then S else S
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
E -> F E'
-----
µ
Paso 2 :
El PRIMERO de ( F E' ) es = { id num ( }.
Agregamos en la tabla M, las entradas :
M[E,id] = E -> F E'
M[E,num] = E -> F E'
M[E,(] = E -> F E'
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
E' -> O E
----
µ
Paso 2 :
El PRIMERO de ( O E ) es = { > < = }.
Agregamos en la tabla M, las entradas :
M[E',>] = E' -> O E
M[E',<] = E' -> O E
M[E',=] = E' -> O E
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
E' -> £
-
µ
Paso 2 :
El PRIMERO de ( £ ) es = { £ }.
NO agregamos entrada a la tabla M, ya que el £ no es columna de la tabla.
El paso 2 NO aplica.
Paso 3 :
El PRIMERO de ( µ ) SI contiene al £, así que agregamos las entradas a la
tabla M, para cada terminal en el SIGUIENTE( E' ) = { then ) ; else
. }
M[E',then] = E' -> £
M[E',)] = E' -> £
M[E',;] = E' -> £
M[E',else] = E' -> £
M[E',.] = E' -> £
═════════════════════════════════════════════════════════════
══════════════
F -> id
--
µ
Paso 2 :
El PRIMERO de ( id ) es = { id }.
Agregamos en la tabla M, las entradas :
M[F,id] = F -> id
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
F -> num
---
µ
Paso 2 :
El PRIMERO de ( num ) es = { num }.
Agregamos en la tabla M, las entradas :
M[F,num] = F -> num
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
F -> ( E )
-------
µ
Paso 2 :
El PRIMERO de ( ( E ) ) es = { ( }.
Agregamos en la tabla M, las entradas :
M[F,(] = F -> ( E )
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
O -> >
-
µ
Paso 2 :
El PRIMERO de ( > ) es = { > }.
Agregamos en la tabla M, las entradas :
M[O,>] = O -> >
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
O -> <
-
µ
Paso 2 :
El PRIMERO de ( < ) es = { < }.
Agregamos en la tabla M, las entradas :
M[O,<] = O -> <
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
O -> = =
----
µ
Paso 2 :
El PRIMERO de ( = = ) es = { = }.
Agregamos en la tabla M, las entradas :
M[O,=] = O -> = =
Paso 3 :
El paso 3 NO APLICA, ya que el PRIMERO de µ no tiene al £.
═════════════════════════════════════════════════════════════
══════════════
TABLA DE ANALISIS SINTACTICO
program Id ( ) ; . , var
A A -> program id ( N ) ; D L .
N N -> id N'
N' N' -> £ N' -> , id N'
D D -> D'
D' D' -> £ D' -> var N : T ; D'
T
R
L L -> S L'
L' L' -> ; S L' L' -> £
S S -> id = E
E E -> F E' E -> F E'
E' E' -> £ E' -> £ E' -> £
F F -> id F -> ( E )
O
: array [ num .. num ] of int real
A
N
N' N' -> £
D
D'
T T -> array [ num .. num ] of R T -> R T -> R
R R -> int R -> real
L
L'
S
E E -> F E'
E'
F F -> num
O
= if then else > < $
A
N
N'
D D -> D'
D' D' -> £
T
R
L L -> S L'
L'
S S -> if E then S else S
E
E' E' -> O E E' -> £ E' -> £ E' -> O E E' -> O E
F
O O -> = = O -> > O -> <
//Clase controlador
import java.awt.Dimension;
import java.awt.FileDialog;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.table.TableColumn;
public class Controlador implements ActionListener {
static Ventana Vistaencontrol;
ModeloDeTablasAS modelo;
ModeloTablaSalida modelosa;
static Object[][] data;
static String [] columnNames;
static TableColumn columna;
public Controlador(Ventana ventana) {
Vistaencontrol = ventana;
//Vistaencontrol.addMouseListener(control);
}
@Override
public void actionPerformed(ActionEvent evento) {
System.out.print(evento.getActionCommand());
if (evento.getActionCommand().equals("Cargar Tabla")){
Sintactico.Sintactico(Ventana.texto.getText());
modelo=new ModeloDeTablasAS(Sintactico.tablaP);
modelosa=new ModeloTablaSalida(Sintactico.PilaImpr,
Sintactico.EntImpr, Sintactico.SalImpr);
Ventana.TAS.setModel(modelo);
Ventana.Salidas.setModel(modelosa);
Ventana.TAS.setFont(new java.awt.Font("Tahoma", 0, 8));
}
if (evento.getActionCommand().equals("Analizis Sintactico")){
for (int i =0; i< Sintactico.EntImpr.size();i++){
Ventana.TSalida.append(Sintactico.EntImpr.elementAt(i)+"\n");
}
for (int i =0; i< Sintactico.PilaImpr.size();i++){
Ventana.TEntrada.append(Sintactico.PilaImpr.elementAt(i)+"\n");
}
for (int i =0; i< Sintactico.SalImpr.size();i++){
Ventana.TPila.append(Sintactico.SalImpr.elementAt(i)+"\n");
}
}
}
public static void main(String[] args){
//modelo = new ModeloDeTablasAS(tabla);
Vistaencontrol = new Ventana(1200, 700);
//modelo = new ModeloDeTablasAS(tabla);
}
}
//Clase ventana
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.TextArea;
import java.awt.TextField;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
@SuppressWarnings("serial")
public class Ventana extends JFrame {
static JButton boton2;
static TextField texto;
static TextArea TEntrada;
static TextArea TPila;
static TextArea TSalida;
static JButton boton1;
static JTable TAS;
static JTable Salidas;
static JScrollPane tableSP;
static MenuBar me;
static Menu m1;
static Menu m2;
static JLabel lpila;
static JLabel lentrada;
static JLabel lsalida;
Controlador control;
static ModeloTablaSalida modelsa;
public Ventana(int x ,int y){
crearVista(x, y);
}
void crearVista(int x, int y){
this.setTitle("Analizador Sintactico");
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(x,y);
this.setLayout(null);
crearObjetos();
adicionarAlFrame();
this.setVisible(true);
registrarOyentes();
}
private void adicionarAlFrame() {
this.setMenuBar(me);
add(texto);
add(boton1);
add(boton2);
add(TAS);
//add(tableTAS);
//add(Salidas);
add(TEntrada);
add(TSalida);
add(TPila);
add(lpila);
add(lentrada);
add(lsalida);
}
void crearObjetos() {
TEntrada = new TextArea();
TSalida = new TextArea();
TPila = new TextArea();
texto = new TextField("Ingrese el Codigo a Analizar");
me = new MenuBar();
m1 = new Menu("Archivo");
m1.add("Abrir");
m1.add("Guardar");
m1.add("Cerrar");
m2 = new Menu ("Acerca de ");
m2.add("Documentacion");
TAS = new JTable();
//modelsa = new ModeloTablaSalida(Sintactico.Pila, Sintactico.EntImpr,
Sintactico.SalImpr);
Salidas = new JTable();
//tableSP = new JScrollPane(Salidas);
//Salidas.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
TEntrada.setBounds(100,350,250,350);
TSalida.setBounds(450,350 ,250, 350);
TPila.setBounds(800, 350, 250, 350);
lpila = new JLabel("pila");
lentrada = new JLabel("entrada");
lsalida = new JLabel("salida");
lpila.setBounds(100, 290, 350, 100);
lentrada.setBounds(450,290, 350, 100);
lsalida.setBounds(800, 290, 350, 100);
boton1 = new JButton("Cargar Tabla");
boton1.setBounds(0, 0, 150, 30);
boton2 = new JButton("Analisis Sintactico");
boton2.setBounds(250, 0, 150, 30);
texto.setBounds(57, 35, 500, 30);
TAS.setBounds(10, 75, 1180, 250);
Salidas.setBounds(300, 350, 250, 300);
control = new Controlador(this);
}
private void registrarOyentes() {
boton1.addActionListener(control);
boton2.addActionListener(control);
}
}
//Clase ModeloDeTablasAS
import javax.swing.table.AbstractTableModel; public class ModeloDeTablasAS extends AbstractTableModel{ private String [] columnNames= {"","program","id","(",")",";",".",",","var",":","array","[","num","..","]","of","int","real","=","if","then","else",">","<","$"}; private Object[][] data; public ModeloDeTablasAS (String [][] TAS ){ data = new Object[16][26]; for (int i =0;i<15;i++){ for (int j =0 ; j <25;j++){ data [i][j]= TAS [i][j]; } } } public String getColumnName(int col){ return columnNames[col]; } @Override public int getColumnCount() { return columnNames.length; } @Override public int getRowCount() { // TODO Auto-generated method stub return data.length; } @Override public Object getValueAt(int row , int col) { // TODO Auto-generated method stub return data[row][col]; } }
// ModeloTablaSalida
import java.util.Vector;
import javax.swing.table.AbstractTableModel;
public class ModeloTablaSalida extends AbstractTableModel{
private String [] columnNames= {"Pila","Entrada","Salida"};
private Object[][] data;
public ModeloTablaSalida(Vector Pila , Vector Entrada, Vector Salida){
int cont=0;
data = new Object[1000][3];
for (int i =0; i < Pila.size();i++){
data[i][0]= Pila.elementAt(i);
//data[i][1]= Entrada.elementAt(i);
//data[i][2]= Salida.elementAt(i);
cont=i;
}
for (int i = 0; i<Entrada.size();i++) data [i][1]=Entrada.elementAt(i);
for (int i = 0; i<Salida.size();i++) data [i][2]=Salida.elementAt(i);
//data [cont][0]="";
//data [cont][1]="";
data [cont][2]=Salida.elementAt(Salida.size()-1);
}
public String getColumnName(int col){
return columnNames[col];
}
@Override
public int getColumnCount() {
return columnNames.length;
}
@Override
public int getRowCount() {
// TODO Auto-generated method stub
return data.length;
}
@Override
public Object getValueAt(int row , int col) {
// TODO Auto-generated method stub
return data[row][col];
}
}
// clase Sintactico
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.Vector;
import javax.swing.JOptionPane;
public class Sintactico{
static ModeloDeTablasAS modelo=null;
static String Palabra[],textoin;
static String[][] tabla = new String[15][25];
static String[][] tablaP = new String[15][25];
static String[] NoTerm = new String[14];
static String[] Term = new String[24];
static Vector<String> Pila = new Vector();
static Vector<String> PilaImpr = new Vector();
static Vector<String> EntImpr = new Vector();
static Vector<String> SalImpr = new Vector();
static void printpila(){
//for (int i=0;i<Pila.size();i++){
// System.out.print(i+" "+ Pila.elementAt(i) + " **** ");
//}
for (int i =0; i< SalImpr.size();i++){
System.out.println (i + " " + SalImpr.elementAt(i));
}
}
static void Sintactico(String textin){
textoin= textin;
Separar_Palabras();
Cargar_TablaM();
Pila.addElement("A");
Pila.addElement("$");
SalImpr.addElement("");
//Cargar_pila(-1,-1);
Cargar_Tablas_Terminales_Noterminales();
//Inicia el Analizador Sintactico
int contpila = 0;
for (int i=0;i<Palabra.length;i++){
guardarV(i);
if(BuscarTerminal(Pila.elementAt(0))!=-1){
if(Pila.elementAt(0).equals(Palabra[i])){
printpila();
Pila.removeElementAt(0);
SalImpr.addElement("");
}else error();
}
else if (BuscaNoTerminal(Pila.elementAt(0))!=-1){
String aux
=tabla[BuscaNoTerminal(Pila.elementAt(0))+1][BuscarTerminal(Palabra[i])+1];
SalImpr.addElement(aux);
if(aux!="ERROR"){
Pila.removeElementAt(0);
String auxdiv[] = aux.split(" ");
int cont = auxdiv.length-1;
int j=0;
int cp=0;
while(cont!=-1){
if(auxdiv[cont].equals("e")){}
else {
if (auxdiv[j].equals("")){}
else {
//System.out.print("__:"+auxdiv[j]);
Pila.add(cp,auxdiv[j]);
cp++;
}
}
cont--;
j++;
}
//printpila();
i--;
}
}else System.out.println("Error Gramatica");
}
printpila();
}
static void guardarV(int k){
String Pilas="",Entrada="",Salida="";
for(int i=k;i<Palabra.length;i++){
Entrada=Entrada+Palabra[i];
}
EntImpr.addElement(Entrada);
for (int i=0;i<Pila.size();i++){
Pilas = Pilas+Pila.elementAt(i);
}
PilaImpr.addElement(Pilas);
for(int
i=0;i<PilaImpr.size();i++)System.out.println(PilaImpr.elementAt(i)+"____"+EntImpr.elementAt(i)
);
}
static int BuscaNoTerminal(String infpila) {
for(int i =0;i<NoTerm.length;i++){
if(infpila.equals(NoTerm[i])) return i;
}
return -1;
}
static void error() {
System.out.print("Error Sintactico");
}
static int BuscarTerminal(String infpila){
for(int i =0;i<Term.length;i++){
if(infpila.equals(Term[i])) return i;
}
return -1;
}
static void Cargar_Tablas_Terminales_Noterminales() {
for (int i=0;i<14;i++){
NoTerm[i]=tabla[i+1][0];
//System.out.println("No Terminales\n"+NoTerm[i]);
}
for (int i=0;i<24;i++){
Term[i]=tabla[0][i+1];
//System.out.println("Terminales\n"+Term[i]);
}
}
public static void Cargar_TablaM() {
File archivo = null;
FileReader fr = null;
BufferedReader br = null;
String linea = null;
int fil = 0;
try {
archivo = new File("archivos\\TAS.txt");
fr = new FileReader(archivo);
br = new BufferedReader(fr);
String[] datos = null;
System.out.println(" SALIDA ");
while ((linea = br.readLine()) != null) {
datos = linea.split("\t");
int col = 0;
for (int i = 0; i < datos.length; i++) {
if (!datos[i].isEmpty()) {
tablaP[fil][col] = datos[i];
//Eliminar la parte de xxx-->
int indice = datos[i].indexOf("->");
if (indice > 0) {
int k = indice + 2;
datos[i] = datos[i].substring(k).trim();
}
//almacenar en la matriz
tabla[fil][col] = datos[i];
}
col++;
}
fil++;
}
//Capturamos las posibles excepciones
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fr != null) {
fr.close();
}
} catch (Exception e2) {
e2.printStackTrace();
}
}
System.out.println("TABLA LL(1) ok");
presentarTabla();
corregir();
presentarTabla();
}
public static void corregir() {
for (int i = 0; i < tabla.length; i++) {
for (int j = 0; j < tabla[0].length; j++) {
if (tabla[i][j] == null) {
tabla[i][j] = "ERROR";
}
}
}
System.out.println("CORRECION ok \n -----------------");
}
public static void presentarTabla() {
for (int i = 0; i < 15; i++) {
for (int j = 0; j < 25; j++) {
System.out.print("[" + tabla[i][j] + "]");
}
System.out.println("");
}
}
static void Cargar_pila(int i, int j) {
}
static void Separar_Palabras(){
//System.out.print("asd");
textoin = textoin + " $";
Palabra=textoin.split(" ");
int j=0;
while(j <= Palabra.length-1){
System.out.println(Palabra [ j ]);
j++;
}
}
}
//FIN ________________