Una Gramtica LL1 es aquella gramtica que no tiene recursin izquierda y no tiene ambigedad,

existen tcnicas para eliminar la recursin izquierda y con eso convertirla a una gramtica LL1
Cuando tienes una Gramtica LL1 entonces utilizas lo que denominas como First y Follow. Lo que
haces es sacar con una serie de reglas (siguiendo un algoritmo) todos los first y follows de la
gramtica.
Los First y Follows son significados para verificar y construir parsers predictivos, son un conjunto
de tokens que se encuentran en el tope de la pila.
Pseudocdigo y algoritmo para calcular los First de una gramtica:
1.-Si X es un terminal FIRST (X) = {X}
2.-Si X -> e es una produccin e (pertenece) FIRST(X)
3.-Si X -> Y1Y2....Yn es una produccin.
a.FIRST(Y1) (es subconjunto de) FIRST(X)
b.Si e (pertenece) FIRST(YK) (para todo) k< i FIRST(Yi) (es subconjunto de) FIRST(X)
c.Si e (pertenece) FIRST(YK) (para todo) I n e (pertenece a) FIRST(X)
Nota (a, b y c pertenecen al paso 3 y solo se toma uno dependiendo el caso)
Algoritmo para calcular los follows:
1.-Si S es el axioma $ (pertenece) FOLLOW(S)
2.-Si A-> B es una produccin FIRST()- { e } (es subconjunto de) FOLLOW(S)
1.- Si hay una produccin A -> B o A -> B Con e (pertenece) FIRST()
FOLLOW(A) (es subconjunto de) FOLLOW(B)

un ejemplo:
E -> TE
E -> +TE | e
T -> FT
T -> *FT | e
F -> (E) | id

FIRST(E) = FIRST(T) = FIRST(F) = {(, id}.
FIRST(E) = {+, e }
FIRST(T) = {*, e }
FOLLOW(E) = FOLLOW(E) = {), $}
FOLLOW(T) = FOLLOW(T) = {+,), $}
FOLLOW(F) = {+,*,), $}

Una vez que tienes los first y follows entonces puedes crear una tabla de smbolos y con ella
puedes construir un compilador que te reconozca y la sintaxis de las instrucciones son correctas o
no con las reglas de tu lenguaje definido en la gramtica.
Se utiliza Flex y Bison para poder hacer los reconocedores lxicos y sintcticos, insertndolos en
programas en C para que generes las reglas provenientes de tus tablas y finalmente hacer tu
compilador.
Predictivo se menciona porque los reconocedores son predicitivos, es decir si tu tienes un if, ya
sabes que puedes o no tener un else y puedes tener reconocedores predictivos botton-up (de
abajo hacia arriba), o top-down (de arriba hacia abajo).
Pseudocdigo pues solamente es una serie de instrucciones para representar un algoritmo pero
de una forma informal, es decir, no con un lenguaje de programacin. Commente se hacen en
ingls y todas las reglas para sacar first, follows y tabla de smbolos te vienen en un pseudocdigo
para que lo sigas y obtengas todo.
Finalmente, la notacin BNF es una forma de escribir las gramticas de una manera formal, te
pongo un ejemplo de una sencilla:
1. <nmero-decimal> ::= <entero-sin-signo> | <fraccin-decimal> |
2. <fraccin-decimal> ::= <entero-sin-signo> <fraccin-decimal>
3. <entero-sin-signo> ::= <dgito> | <dgito> <entero-sin-signo>
4. <dgito> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
FIRST
Si es cualquier cadena de smbolos gramaticales, se considera FIRST() como el conjunto de
terminales que encabezan las cadenas derivadas de . Si =
*
=> , entonces tambin est en
FIRST ().
Si es cualquier cadena de smbolos gramaticales, se considera FIRST() como el conjunto de
terminales que encabezan las cadenas derivadas de . Si =*=> , entonces tambin est en
Para calcular FIRST(X) para algn smbolo X de la gramtica, se aplican las siguientes reglas
hasta que no se pueda aadir nada nuevo al conjunto FIRST:
1. Si X es terminal, entonces FIRST(X) es {X}.
2. Si X es no terminal y existe la produccin X , entonces aadir a FIRST(X).
3. Si X es no terminal y X Y1 Y2 .. . Yk es una produccin entonces, para todo i (con i
variando desde 1 hasta k) tal que Y1 , Y2 , ..., Yi-1 sean todos no terminales y FIRST(Y1),
FIRST(Y2), ..., FIRST(Yi-1) contengan todos , se aaden todos los smbolos no nulos de
FIRST(Yi ) a FIRST(X). Finalmente, si est en FIRST(Yj ) para j = 1, 2, ..., k (o sea, en
todos), entonces se aade a FIRST(X).
Dicho de otra forma, lo anterior significa que todos los elementos de FIRST(Y1), excepto
, pertenecen tambin a FIRST(X). Si Y1 no deriva , entonces ya ha terminado el clculo
de FIRST(X), pero en caso contrario, es decir, si Y1=*=> , entonces todos los elementos de
FIRST(Y2) excepto pertenecen tambin a FIRST(X), y as sucesivamente. Finalmente, si
todos los Yi derivan , entonces se aade a FIRST(X).

FOLLOW
Se define FOLLOW(A), para el no terminal A, como el conjunto de terminales a que pueden
aparecer inmediatamente a la derecha de A en alguna forma sentencial, es decir, el conjunto de
terminales a tal que haya una derivacin de la forma S=*=>Aa para algn y . Si A puede ser el
smbolo de ms a la derecha en alguna forma sentencial, entonces $ est en FOLLOW(A).
Para calcular FOLLOW(A) para un smbolo no terminal A, se aplican las siguientes reglas hasta que
no se pueda aadir nada ms al conjunto FOLLOW.
1. $ est en FOLLOW(S), siendo S el axioma de G.
2. Si existe una produccin A B, entonces todo lo que est en FIRST(), excepto , est en
FOLLOW(B).
3. Si existe la produccin A B y FIRST() contiene (es decir, =*=>), o bien si existe una
produccin A B, entonces todo lo que est en FOLLOW(A) est en FOLLOW(B).

http://www.itescam.edu.mx/principal/sylabus/fpdb/recursos/r104052.PDF
http://www-lt.ls.fi.upm.es/compiladores/procesadores/Documentos/FirstFollow.pdf