UNIVERSIDAD CENTRAL

Ingeniera de Software
Docente: Julio Cesar Sierra
Tabla de Anlisis Sintctico
Autores:
Cristian
Javier Dario Becerra
Enrique Pinzon
Wilson Barragan
David Fernando Valverde
Cd.: 1032403489

Bogot D.C 25 de Marzo de 2015

Contenido
Gramtica...................................................................................................... 3
Convenciones................................................................................................. 3
Gramtica Reescrita:...................................................................................... 3
Eliminacin ambigedad:............................................................................... 3
Gramtica sin ambigedad:...........................................................................4
Eliminacin recursin por la Izquierda:...........................................................4
Gramtica sin recursin por la Izquierda:.......................................................5
Conjuntos primero:......................................................................................... 5

Gramtica:
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 expresin then proposicion else

proposicion
8. expresion factor oprel expresion | factor
9. factor id | num | (expresion)
10. oprel > | < | ==

Convenciones:
Programa
Program
Lista_identificadores
Declaraciones
lista_proposiciones
tipo
tipo_estandar
Proposicin
Expresion
Factor

P
Prog
L_I
D
L_P
T
T_E
pr
E
F

Gramtica Reescrita:
1. P Prog id (L_I) ; D L_P .
2. L_I id | L_I, id
3. D D var L_I : T; |
4. T T_E| array [num .. num] of T_E
5. T_E int | real
6. L_P pr| L_P ; pr
7. pr id = E | if E then pr else pr
8. E F oprel E | F
9. F id | num | (E)
10. oprel > | < | ==

Eliminacin ambigedad:
Si A -> 1 | 2 | | n |
Ent A = A |
A = 1 | 2 | | n
8. E F oprel E | F
A=E
=F
1 = oprel E
2 =
E F E
E oprel E |

Gramtica sin ambigedad:

P Prog id (L_I) ; D L_P .
L_I id | L_I, id
D D var L_I : T; |
T T_E| array [num .. num] of T_E
T_E int | real
L_P pr| L_P ; pr
pr id = E | if E then pr else pr
E F E
9. E oprel E |
10. F id | num | (E)
11. oprel > | < | ==
1.
2.
3.
4.
5.
6.
7.
8.

Eliminacin recursin por la Izquierda:

Si A -> A1 | A2 | | An | 1 | 2 | | m
Ent A -> 1A | 2A | | mA
A -> 1A | 2A | | nA |
2. L_I id | L_I , id
A = L_I
1 = , id
1 = id
L_I id L_I
L_I , id L_I |
3. D D var L_I : T ; |
A=D
1 = var L_I : T ;
1 =
D D
D var L_I : T ; D |
6. L_P pr | L_P ; pr
A = L_P
1 = ; pr
L_P pr L_P
L_P ; S L |

Gramtica sin recursin por la Izquierda:

1. P Prog id (L_I) ; D L_P .
2. L_I id L_I

3. L_I , id L_I |
4. D D
5. D var L_I : T ; D |
6. T T_E| array [num .. num] of T_E
7. T_E int | real
8. L_P pr L_P
9. L_P ; S L |
10. pr id = E | if E then pr else pr
11. E F E
12. E oprel E |
13. F id | num | (E)
14. oprel > | < | ==

Conjuntos primero:
1. P prog id ( L_I ) ; D L_P .
Prim (P) = {Prim(prog), }
Prim(prog) = {prog} no contiene
Prim(A) = Prim(P)={program}
2. L_I id L_I
Prim (L_I) = {Prim(id), }
Prim(id) = {id} no contiene
Prim(L_I) = {id}
3. L_I , id L_I|
Prim(L_I) = {Prim(,), .} U {Prim()}
Prim(,) = { , } no contiene
Prim() = { }
Prim(L_I) = { , , }
4. D D
Prim(D) = {var, }
5. D var L_I : T ; D |
Prim(D) = {Prim(var), } U {Prim()}
Prim(var) = {var} no contiene
Prim() = { }
Prim(D) = {var, }
6. T T_E| array [num .. num] of T_E
Prim(T)= {Prim(T_E)} U {Prim(array }
Prim(T_E) = {int, real}
Prim(array) = {array} no contiene
Prim(T) = {int, real, array}
7. T_E int | real
Prim(T_E) = {Prim(int)} U {Prim(real)}
Prim(int) = {int}
Prim(real)={real}
Prim(T_E) = {int, real}
8. L_P pr L_P

Prim(L_P) = {Prim(pr), Prim(L_P)}

Prim(pr) = {id, if} no contiene
Prim(L_P) = {id, if}
9. L_P ; S L |
Prim(L_P) = {Prim(;), } U {Prim()}
Prim(;) = {;} no contiene
Prim() = {}
Prim(L_P) = { ;, }
10. pr id = E | if E then pr else pr
Prim(pr) = {Prim(id), } U {Prim(if), }
Prim(id)= {id} no contiene
Prim(if) = {if} no contiene
Prim(pr) = {id, if}
11. E F E
Prim(E) = {Prim(F), Prim(E)}
Prim(F) = {id, num, ( } no contiene
Prim(E) = {id, num, ( }

12. E oprel E |

Prim(E) = {Prim(oprel), 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. oprel > | < | ==
Prim(oprel) = {Prim(>)} U {Prim(<)} U {Prim(=)}
Prim(oprel) = {>, <, =}

Conjuntos Primero: