Compiladores Parsers Parsers Predictivos, LL(0), LL(k), Parsers shift-reduce, Construcción de un Parser LL(0)

Oscar Bonilla 2Universidad Galileo Resumen Parsers Predictivos Implementando un Parser Ejemplo de un Parser shift-reduce ¿Por qué es difícil construir un parser engine? LR(k) parser tables Construyendo un Parser Engine LR(0)

Oscar Bonilla 3Universidad Galileo Parsers Predictivos Algunas gramáticas pueden parsearse usando un algoritmo conocido como Recursive Descent Recursive Descent: Una función para cada no terminal, una clausula para cada terminal

Oscar Bonilla 4Universidad Galileo Ejemplo: Parser Predictivo Gramática:  if then else  begin  print  end  ;  num = num

Oscar Bonilla 5Universidad Galileo Ejemplo: Parser Predictivo Gramática:  if then else  begin  print  end  ;  num = num void S (void) { switch(token) { case IF: eat(IF); E(); eat(THEN); S(); eat(ELSE); S(); break; case BEGIN: eat(BEGIN); S(); L(); break; case PRINT: eat(PRINT); E(); break; default: error(); } void L (void) { switch(token) { case END: eat(END); break; case SEMI: eat(SEMI); S(); L(); break; default: error(); } void E (void) { eat(NUM); eat(EQ); eat(NUM); }

Oscar Bonilla 6Universidad Galileo Ejemplo: Parser Predictivo Gramática:  if then else  begin  print  end  ;  num = num void S (void) { switch(token) { case IF: eat(IF); E(); eat(THEN); S(); eat(ELSE); S(); break; case BEGIN: eat(BEGIN); S(); L(); break; case PRINT: eat(PRINT); E(); break; default: error(); } void L (void) { switch(token) { case END: eat(END); break; case SEMI: eat(SEMI); S(); L(); break; default: error(); } void E (void) { eat(NUM); eat(EQ); eat(NUM); } No terminales

Oscar Bonilla 7Universidad Galileo Ejemplo: Parser Predictivo Gramática:  if then else  begin  print  end  ;  num = num void S (void) { switch(token) { case IF: eat(IF); E(); eat(THEN); S(); eat(ELSE); S(); break; case BEGIN: eat(BEGIN); S(); L(); break; case PRINT: eat(PRINT); E(); break; default: error(); } void L (void) { switch(token) { case END: eat(END); break; case SEMI: eat(SEMI); S(); L(); break; default: error(); } void E (void) { eat(NUM); eat(EQ); eat(NUM); } terminales

Oscar Bonilla 8Universidad Galileo Parsers Predictivos Los parsers predictivos sólo funcionan para gramáticas donde el primer símbolo terminal de cada subexpresión provee suficiente información para determinar qué producción usar.

Oscar Bonilla 9Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) Ejemplos: ( 1 * 2 – 3 ) + 4 ( 1 * 2 – 3 )

Oscar Bonilla 10Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) void E (void) { switch(token) { case ??: E(); eat(PLUS); T(); break; case ??: E(); eat(MINUS); T(); break; case ??: T(); break; default: error(); } Void T (void) { switch(token) { case ??: T(); eat(TIMES); F(); break; case ??: T(); eat(DIV); F(); break; case ??: F(); break; default: error(); }

Oscar Bonilla 11Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) void E (void) { switch(token) { case ??: E(); eat(PLUS); T(); break; case ??: E(); eat(MINUS); T(); break; case ??: T(); break; default: error(); } Void T (void) { switch(token) { case ??: T(); eat(TIMES); F(); break; case ??: T(); eat(DIV); F(); break; case ??: F(); break; default: error(); } ¿Qué ponemos aquí?

Oscar Bonilla 12Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) void E (void) { switch(token) { case ??: E(); eat(PLUS); T(); break; case ??: E(); eat(MINUS); T(); break; case ??: T(); break; default: error(); } Void T (void) { switch(token) { case ??: T(); eat(TIMES); F(); break; case ??: T(); eat(DIV); F(); break; case ??: F(); break; default: error(); } ( 1 * 2 – 3 ) + 4

Oscar Bonilla 13Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) void E (void) { switch(token) { case ??: E(); eat(PLUS); T(); break; case ??: E(); eat(MINUS); T(); break; case ??: T(); break; default: error(); } Void T (void) { switch(token) { case ??: T(); eat(TIMES); F(); break; case ??: T(); eat(DIV); F(); break; case ??: F(); break; default: error(); } ( 1 * 2 – 3 ) + 4

Oscar Bonilla 14Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) void E (void) { switch(token) { case LPAREN: E(); eat(PLUS); T(); break; case ??: E(); eat(MINUS); T(); break; case ??: T(); break; default: error(); } Void T (void) { switch(token) { case ??: T(); eat(TIMES); F(); break; case ??: T(); eat(DIV); F(); break; case ??: F(); break; default: error(); } ( 1 * 2 – 3 ) + 4

Oscar Bonilla 15Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) void E (void) { switch(token) { case LPAREN: E(); eat(PLUS); T(); break; case ??: E(); eat(MINUS); T(); break; case ??: T(); break; default: error(); } Void T (void) { switch(token) { case ??: T(); eat(TIMES); F(); break; case ??: T(); eat(DIV); F(); break; case ??: F(); break; default: error(); } ( 1 * 2 – 3 ) + 4 ( 1 * 2 – 3 )

Oscar Bonilla 16Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) void E (void) { switch(token) { case LPAREN: E(); eat(PLUS); T(); break; case ??: E(); eat(MINUS); T(); break; case ??: T(); break; default: error(); } Void T (void) { switch(token) { case ??: T(); eat(TIMES); F(); break; case ??: T(); eat(DIV); F(); break; case ??: F(); break; default: error(); } ( 1 * 2 – 3 ) + 4 ( 1 * 2 – 3 )

Oscar Bonilla 17Universidad Galileo Ejemplo Gramática  +  -   *  /   id  num  ( ) void E (void) { switch(token) { case LPAREN: E(); eat(PLUS); T(); break; case ??: E(); eat(MINUS); T(); break; case LPAREN: T(); break; default: error(); } Void T (void) { switch(token) { case ??: T(); eat(TIMES); F(); break; case ??: T(); eat(DIV); F(); break; case ??: F(); break; default: error(); } ( 1 * 2 – 3 ) + 4 ( 1 * 2 – 3 )

Oscar Bonilla 18Universidad Galileo First(), Follow() y Nullable() Nullable(X) es verdadero si X puede derivar  FIRST(  ) es el conjunto de terminales que pueden comenzar strings derivados de  FOLLOW(X) es el conjunto de terminales que pueden seguir a X. Esto es, t  FOLLOW(X) si hay una derivación que contenga Xt. Esto puede ocurrir si una derivación contiene XYZt donde tanto Y como Z derivan .

Oscar Bonilla 19Universidad Galileo Algoritmo para First(), Follow() y Nullable() Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración

Oscar Bonilla 20Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW X Y Z

Oscar Bonilla 21Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW X Y Z

Oscar Bonilla 22Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Y Z

Oscar Bonilla 28Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Y Z i = 1, j = 2, k = 1

Oscar Bonilla 31Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Y Z d i = 1, j = 2, k = 1

Oscar Bonilla 36Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Y Z d

Oscar Bonilla 53Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Y d Z d i = 2, j = 3, k = 3

Oscar Bonilla 60Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Y d Z d

Oscar Bonilla 64Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Yyesd Znod

Oscar Bonilla 65Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Yyesd Znod i = 1, j = 2, k = 0

Oscar Bonilla 72Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Yyescd Znod i = 1, j = 2, k = 1

Oscar Bonilla 77Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xno Yyescd Znod

Oscar Bonilla 81Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xyes Y cd Znod

Oscar Bonilla 82Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xyes Y cd Znod i = 1, j = 2, k = 1

Oscar Bonilla 85Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xyesc Y cd Znod i = 1, j = 2, k = 1

Oscar Bonilla 92Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xyesc Y cd Znod

Oscar Bonilla 98Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xyesa c Yyescd Znod i = 1, j = 2, k = 1

Oscar Bonilla 103Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xyesa c Yyescd Znod

Oscar Bonilla 106Universidad Galileo Ejemplo Gramática  d     c   a Incializar FIRST y FOLLOW al conjunto vacío y nullable a falso Para cada símbolo terminal Z, FIRST[Z] = {Z} Repetir Para cada producción X  Y 1 Y 2    Y k Si Y 1    Y k son todos nullable (o si k=0) entonces nullable[X] = true Para cada i = 1 to k, j = i +1 to k Si Y 1    Y i-1 son todos nullable (o si i = 1) entonces FIRST[X] = FIRST[X]  FIRST[Y i ] Si Y i+1    Y k son todos nullable (o si i = k ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FOLLOW[X] Si Y i+1    Y j-1 son todos nullable (o si i +1 = j ) entonces FOLLOW[Y i ] = FOLLOW[Y i ]  FIRST[Y j ] Hasta que FIRST, FOLLOW y nullable no cambien en esta iteración nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d

Oscar Bonilla 107Universidad Galileo Construyendo un Parser Predictivo Usando la información de FIRST y FOLLOW podemos crear una tabla de parseo Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 108Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X Y Z Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 112Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X Y Z  d Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 115Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X Y Z   d  Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 119Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X Y   Z   d  Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 120Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X Y   Z   d  Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 121Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X Y    c   Z   d  Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 124Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X  Y    c   Z   d  Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 127Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X   a  Y    c   Z   d  Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X)

Oscar Bonilla 130Universidad Galileo Ejemplo: Tabla de Parser Predictivo nullableFIRSTFOLLOW Xyesa ca c d Yyesca c d Znoa c d Gramática  d     c   a acd X   a  Y    c   Z   d  Ingresamos la producción X   en la fila X, columna T de una tabla para cada T  FIRST(  ) Si  es nullable, ingresamos la producción en la fila X, columna T para cada T  FOLLOW(X) ¡¡Múltiples Entradas!!

Oscar Bonilla 131Universidad Galileo Parsers Predictivos Los parsers predictivos sólo funcionan para gramáticas donde el primer símbolo terminal de cada subexpresión provee suficiente información para determinar qué producción usar. ¡La gramática que usamos es ambigua!

Oscar Bonilla 132Universidad Galileo Gramáticas LL(1) A las gramáticas para las que la tabla de parseo de un parser predictivo no contiene entradas duplicadas se les llama LL(1) Si generalizamos la noción de FIRST para describir k tokens (en vez de 1), podemos construir una tabla de parseo LL(k) Esto casi no se hace ya que las tablas de parseo serían demasiado grandes.

Oscar Bonilla 133Universidad Galileo Recursión Izquierda Si una gramática tiene recursión izquierda, no puede ser parseada por un parser predictivo Ejemplo:  +  Las gramáticas con recursión izquierda no son LL(1)

Oscar Bonilla 134Universidad Galileo Eliminando Recursión Izquierda Para eliminar la recursión izquierda, podemos reescribir la gramática usando recursión derecha.

Oscar Bonilla 135Universidad Galileo Ejemplo: Eliminando Recursión Izquierda  +    +  

Oscar Bonilla 136Universidad Galileo Eliminando Recursión Izquierda En general, cuando tenemos producciones de la forma   y   donde  no comienza con, sabemos que esto deriva strings de la forma   *, así que la podemos reescribir usando recursión derecha.

Oscar Bonilla 137Universidad Galileo Factorización Izquierda Un problema similar ocurre cuando dos producciones con el mismo no-terminal comienzan con el mismo símbolo. Ejemplo:  if then else  if then En este caso, podemos factorizar la gramática por la izquierda, es decir, tomar las terminaciones posibles y crear un nuevo no terminal que las incluya.

Oscar Bonilla 138Universidad Galileo Ejemplo: Factorización Izquierda  if then else  if then    else Nota: La gramática todavía es ambigua, pero las producciones resultantes no van a ser problema para un parser predictivo (podemos usar siempre la producción “else ”)

Oscar Bonilla 140Universidad Galileo Implementando un Parser Técnicas diferentes –Cada una puede manejar distintas CFGs –Categorización de Técnicas

Oscar Bonilla 141Universidad Galileo Implementando un Parser Técnicas diferentes –Cada una puede manejar distintas CFGs –Categorización de Técnicas ()

Oscar Bonilla 142Universidad Galileo Implementando un Parser Técnicas diferentes –Cada una puede manejar distintas CFGs –Categorización de Técnicas () L – parsear de izquierda a derecha R – parsear de derecha a izquierda

Oscar Bonilla 143Universidad Galileo Implementando un Parser Técnicas diferentes –Cada una puede manejar distintas CFGs –Categorización de Técnicas () L - leftmost derivation R - rightmost derivation

Oscar Bonilla 144Universidad Galileo Implementando un Parser Técnicas diferentes –Cada una puede manejar distintas CFGs –Categorización de Técnicas () Número de caracteres de lookahead

Oscar Bonilla 145Universidad Galileo Implementando un Parser Técnicas diferentes –Cada una puede manejar distintas CFGs –Categorización de Técnicas –Ejemplos: LL(0), LR(1) ()

Oscar Bonilla 146Universidad Galileo Implementando un Parser Técnicas diferentes –Cada una puede manejar distintas CFGs –Categorización de Técnicas –Ejemplos: LL(0), LR(1) Ya vimos parser LL(1) Vamos a estudiar parsers LR(k) () LRk

Oscar Bonilla 148Universidad Galileo Por qué usar un parser LR(k) Puede ser construido para que reconozca una gran gama de CFGs –Virtualmente todas las construcciones de los lenguajes de programación Es el método más general de parseo que no necesita retroceder Se puede contruir un parser engine muy eficiente Puede detectar errores sintácticos tan pronto como es posible detectarlos

Oscar Bonilla 149Universidad Galileo Veamos la implementación de un Parser Funcionamiento de un parser LR(k) parsea de izquierda a derecha rightmost derivation –Comenzamos con el string de entrada –Terminamos con el símbolo de inicio

Oscar Bonilla 150Universidad Galileo Acciones de un Parser shift-reduce Arbol de Parseo

Oscar Bonilla 151Universidad Galileo Acciones de un Parser shift-reduce Parse Tree Arbol de Parseo

Oscar Bonilla 162Universidad Galileo Acciones de un Parser shift-reduce No podemos crear un sub-árbol de parseo completo Necesitamos la información del look ahead Por lo tanto, mantenemos estado Parse Tree

Oscar Bonilla 163Universidad Galileo Acciones de un Parser shift-reduce Parse Tree Estado Actual

Oscar Bonilla 164Universidad Galileo Acciones de un Parser shift-reduce Stack Símbolo Actual stack Acción del Parser Parser Engine

Oscar Bonilla 165Universidad Galileo Acciones de un Parser shift-reduce Shift –Shift del símbolo actual al top del stack –Movemos el pointer actual Reduce –Aplicamos una producción –El top del stack debe hacer match con el RHS –Eliminamos esos símbolos del stack –Agregamos los no-terminales del LHS Accept –Llegamos al final del stream de input & –El stack sólo tiene el símbolo de inicio Reject –Llegamos al final del stream de input, pero –El stack tiene más que el símbolo de inicio

Oscar Bonilla 166Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num)

Oscar Bonilla 167Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num)

Oscar Bonilla 168Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num)   ( )  -  num  +  -  *

Oscar Bonilla 171Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num)   ( )  -  num  +  -  * num

Oscar Bonilla 172Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num)   ( )  -  num  +  -  * num SHIFT

Oscar Bonilla 173Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num)   ( )  -  num  +  -  * num

Oscar Bonilla 174Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num)   ( )  -  num  +  -  * num REDUCE

Oscar Bonilla 175Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num) num   ( )  -  num  +  -  * REDUCE

Oscar Bonilla 176Universidad Galileo Ejemplo: Parser Shift-Reduce *(+num) num   ( )  -  num  +  -  *

Oscar Bonilla 177Universidad Galileo Ejemplo: Parser Shift-Reduce (+num) num*   ( )  -  num  +  -  * * SHIFT

Oscar Bonilla 178Universidad Galileo Ejemplo: Parser Shift-Reduce (+num) num*   ( )  -  num  +  -  * *

Oscar Bonilla 179Universidad Galileo Ejemplo: Parser Shift-Reduce (+num) num*   ( )  -  num  +  -  * * REDUCE

Oscar Bonilla 180Universidad Galileo Ejemplo: Parser Shift-Reduce (+num) num*   ( )  -  num  +  -  * REDUCE

Oscar Bonilla 181Universidad Galileo ( Ejemplo: Parser Shift-Reduce +num) num*   ( )  -  num  +  -  *

Oscar Bonilla 182Universidad Galileo Ejemplo: Parser Shift-Reduce +num) num*(   ( )  -  num  +  -  * ( SHIFT

Oscar Bonilla 183Universidad Galileo Ejemplo: Parser Shift-Reduce +num) num*(   ( )  -  num  +  -  * (

Oscar Bonilla 184Universidad Galileo Ejemplo: Parser Shift-Reduce *+num) num(   ( )  -  num  +  -  * ( num SHIFT

Oscar Bonilla 185Universidad Galileo Ejemplo: Parser Shift-Reduce *+num) num(   ( )  -  num  +  -  * ( num

Oscar Bonilla 186Universidad Galileo Ejemplo: Parser Shift-Reduce *+num) num(   ( )  -  num  +  -  * ( num REDUCE

Oscar Bonilla 187Universidad Galileo Ejemplo: Parser Shift-Reduce *+num) num(   ( )  -  num  +  -  * ( REDUCE

Oscar Bonilla 188Universidad Galileo + Ejemplo: Parser Shift-Reduce *num) num(   ( )  -  num  +  -  * (

Oscar Bonilla 189Universidad Galileo Ejemplo: Parser Shift-Reduce *num) num( +   ( )  -  num  +  -  * ( + SHIFT

Oscar Bonilla 190Universidad Galileo Ejemplo: Parser Shift-Reduce *num) num( +   ( )  -  num  +  -  * ( +

Oscar Bonilla 191Universidad Galileo Ejemplo: Parser Shift-Reduce *num) num( +   ( )  -  num  +  -  * ( + REDUCE

Oscar Bonilla 192Universidad Galileo Ejemplo: Parser Shift-Reduce *num) num( +   ( )  -  num  +  -  * ( REDUCE

Oscar Bonilla 193Universidad Galileo num Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * (

Oscar Bonilla 194Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * ( num SHIFT

Oscar Bonilla 195Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * ( num

Oscar Bonilla 196Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * ( num REDUCE

Oscar Bonilla 197Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * ( REDUCE

Oscar Bonilla 198Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * (

Oscar Bonilla 201Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * (

Oscar Bonilla 202Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * ( ) SHIFT

Oscar Bonilla 203Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * ( )

Oscar Bonilla 204Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * ( ) REDUCE

Oscar Bonilla 205Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * REDUCE

Oscar Bonilla 206Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  *

Oscar Bonilla 209Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  *

Oscar Bonilla 210Universidad Galileo Ejemplo: Parser Shift-Reduce *) num( +   ( )  -  num  +  -  * ACCEPT

Oscar Bonilla 211Universidad Galileo ¿Qúe hace el parser engine? Si los símbolos en el top del stack hacen match con el RHS de una producción, hacemos la reducción –Pop del RHS del top del stack –Push del símbolo del LHS al stack Si no se encuentra ninguna producción, se hace un shift – push del input actual al stack Si el input está vacío –accept si en el stack sólo está el símbolo de inicio –reject en cualquier otro caso Parser Engine

Oscar Bonilla 212Universidad Galileo Resumen Parsers Predictivos Implementando un Parser Ejemplo de un Parser shift-reduce ¿Por qué es difícil construir un Parser Engine? LR(k) parser tables Construyendo un Parser Engine LR(0)

Oscar Bonilla 213Universidad Galileo ¿Qúe hace el parser engine? Si los símbolos en el top del stack hacen match con el RHS de una producción, hacemos la reducción –Pop del RHS del top del stack –Push del símbolo del LHS al stack Si no se encuentra ninguna producción, se hace un shift – push del input actual al stack Si el input está vacío –accept si en el stack sólo está el símbolo de inicio –reject en cualquier otro caso Parser Engine

Oscar Bonilla 214Universidad Galileo ¡No es tan simple! Muchas opciones para reducir –Match con múltiples RHS Elección entre shift y reduce –Stack contiene un RHS –Pero puede ser que reducir no sea lo más adecuado –Puede ser que si hacemos shift del input, después encontremos una reducción distinta

Oscar Bonilla 215Universidad Galileo Ejemplo: Parser Shift-Reduce   ( )  -  num  +  -  * Un cambio en la gramática

Oscar Bonilla 219Universidad Galileo Ejemplo: Parser Shift-Reduce -num   ( )  -  num  +  -  *

Oscar Bonilla 220Universidad Galileo Ejemplo: Parser Shift-Reduce -num   ( )  -  num  +  -  * num

Oscar Bonilla 221Universidad Galileo num Ejemplo: Parser Shift-Reduce -num   ( )  -  num  +  -  * num SHIFT

Oscar Bonilla 222Universidad Galileo num Ejemplo: Parser Shift-Reduce -num   ( )  -  num  +  -  * num

Oscar Bonilla 223Universidad Galileo num Ejemplo: Parser Shift-Reduce -num   ( )  -  num  +  -  * num REDUCE

Oscar Bonilla 224Universidad Galileo Ejemplo: Parser Shift-Reduce -num   ( )  -  num  +  -  * num REDUCE

Oscar Bonilla 225Universidad Galileo Ejemplo: Parser Shift-Reduce -num   ( )  -  num  +  -  * num

Oscar Bonilla 226Universidad Galileo - Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - SHIFT

Oscar Bonilla 227Universidad Galileo - Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num -

Oscar Bonilla 228Universidad Galileo - Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡¡Tenemos elección!!! REDUCE

Oscar Bonilla 229Universidad Galileo - Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!! REDUCE

Oscar Bonilla 230Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!! REDUCE

Oscar Bonilla 231Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!!

Oscar Bonilla 232Universidad Galileo num Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!! SHIFT

Oscar Bonilla 233Universidad Galileo num Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!!

Oscar Bonilla 234Universidad Galileo num Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!! REDUCE

Oscar Bonilla 235Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!! REDUCE

Oscar Bonilla 236Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!!

Oscar Bonilla 237Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ¡¡Pero esto no es lo correcto!! ¡¡No hay más acciones!! ERROR

Oscar Bonilla 238Universidad Galileo Ejemplo: Parser Shift-Reduce num - Pero este input es perfectamente válido para la gramática Elegimos la producción equivocada Veamos cuál es la producción apropiada

Oscar Bonilla 239Universidad Galileo - Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - Tenemos elección REDUCE El paso anterior a nuestro error

Oscar Bonilla 240Universidad Galileo - Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - Usamos la otra producción REDUCE

Oscar Bonilla 241Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - REDUCE Usamos la otra producción

Oscar Bonilla 242Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num -

Oscar Bonilla 243Universidad Galileo num Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - SHIFT

Oscar Bonilla 244Universidad Galileo num Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num -

Oscar Bonilla 245Universidad Galileo num Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - REDUCE

Oscar Bonilla 246Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - REDUCE

Oscar Bonilla 251Universidad Galileo Ejemplo: Parser Shift-Reduce num   ( )  -  num  +  -  * num - ACCEPT

Oscar Bonilla 252Universidad Galileo ¡No es tan simple! Muchas opciones para reducir –Match con múltiples RHS Elección entre shift y reduce –Stack contiene un RHS –Pero puede ser que reducir no sea lo más adecuado –Puede ser que si hacemos shift del input después encontremos una reducción distinta Mantenemos información adicional

Oscar Bonilla 254Universidad Galileo Construyendo un Parser LR(k) Vamos a construir unos cuantos parsers LR(k) –LR(0), –SLR (o simple LR) –LR(1)

Oscar Bonilla 255Universidad Galileo Construyendo un Parser LR(k) Vamos a construir unos cuantos parsers LR(k) –LR(0), –SLR (o simple LR) –LR(1) Ya seguimos las acciones del parseo ¿Qué hay en el parse engine? –elegir entre shift y reduce –elegir la reducción correcta

Oscar Bonilla 256Universidad Galileo Acciones de un Parser Shift-Reduce Stack Símbolo Actual stack Acción del Parser Parser Engine

Oscar Bonilla 257Universidad Galileo Construyendo un Parser LR(k) Creamos un DFA –Codifica todos los posibles estados en que puede estar el parser –Ocurre una transición de estado del DFA en terminales y no-terminales Creamos una Tabla de Parseo –Guarda que acción debe ser tomada a partir del estado actual y el símbolo de entrada actual Mantenemos un stack de estados –En paralelo con el stack de símbolos

Oscar Bonilla 258Universidad Galileo LR(k) Parser Engine Símbolo Actual Acción del Parser LR(k) Parser Engine Stack de Símbolos Stack de Estados

Oscar Bonilla 259Universidad Galileo Tablas de Parseo Buscamos –[top del stack de estados] –[ símbolo de entrada] en la tabla de parseo Ejecutamos la acción descrita

Oscar Bonilla 260Universidad Galileo Tablas de Parseo Shift to sn –Push del token de entrada en el stack de símbolos –Push sn en el stack de estados –Avanzamos al siguiente símbolo de entrada

Oscar Bonilla 261Universidad Galileo Tablas de Parseo Reduce (n) –Pop de ambos stacks tantas veces como el número de símbolos en el RHS de la regla n –Push LHS de la regla n en el stack de símbolos –Buscar [top del stack de estados][top del stack de símbolos] –Push de ese estado (en goto k) en el stack de estados

Oscar Bonilla 262Universidad Galileo Tablas de Parseo Accept –Dejar de parsear y reportar éxito

Oscar Bonilla 263Universidad Galileo Tablas de Parseo Error –Dejar de parsear y reportar Error

Oscar Bonilla 264Universidad Galileo Ejemplo LR La gramática  $(1)  ( )(2)  ( )(3)

Oscar Bonilla 265Universidad Galileo Pregunta La gramática  $(1)  ( )(2)  ( )(3) ¿Cuál es el lenguaje aceptado por esta CFG?

Oscar Bonilla 266Universidad Galileo Tabla de Parseo en Acción La gramática  $(1)  ( )(2)  ( )(3)

Oscar Bonilla 267Universidad Galileo Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3)

Oscar Bonilla 268Universidad Galileo Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) $

Oscar Bonilla 269Universidad Galileo Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $

Oscar Bonilla 270Universidad Galileo Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$

Oscar Bonilla 271Universidad Galileo Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )()($

Oscar Bonilla 274Universidad Galileo ( s2 ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ ))($

Oscar Bonilla 275Universidad Galileo s2 ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ ))(($

Oscar Bonilla 278Universidad Galileo s2 ( ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ ))(($

Oscar Bonilla 279Universidad Galileo s2 ( ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$

Oscar Bonilla 282Universidad Galileo s5 ) s2 ( ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$

Oscar Bonilla 287Universidad Galileo s5 ) s2 ( ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(() s5 ) s2 ( $

Oscar Bonilla 288Universidad Galileo X s2 ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$

Oscar Bonilla 291Universidad Galileo s3 X s2 ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$

Oscar Bonilla 295Universidad Galileo s4 ) s3 X s2 ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$

Oscar Bonilla 299Universidad Galileo s4 ) s3 X s2 ( Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$ s4 ) s3 X s2 (

Oscar Bonilla 300Universidad Galileo X Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$

Oscar Bonilla 303Universidad Galileo s1 X Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$

Oscar Bonilla 306Universidad Galileo s1 X Tabla de Parseo en Acción Tabla de Acciones La gramática  $(1)  ( )(2)  ( )(3) s0 $ )(()$ Accept

Oscar Bonilla 308Universidad Galileo Items LR(0) Tenemos que capturar cuánto de una producción hemos escaneado hasta ahora  ( ) ¿Estamos aquí?¿o aquí?

Oscar Bonilla 309Universidad Galileo Items LR(0) Tenemos que capturar cuánto de una producción hemos escaneado hasta ahora Representado por 4 ítems –  ( )  ( )

Oscar Bonilla 310Universidad Galileo Ejemplo de Items La gramática  $  ( ) Items  $  ( )

Oscar Bonilla 311Universidad Galileo Idea clave de los Items Si el “estado actual” contiene el ítem A   c  y el símbolo actual en el buffer de entrada es c –El estado le dice al parser que ejecute un shift –El siguiente estado va a contener A   c  Si el “estado” contiene el ítem A   –El estado le dice al parser que ejecute un reduce Si el “estado” contiene el ítem S   $ y el buffer de entrada está vacío –El estado le dice al parser que ejecute un accept

Oscar Bonilla 312Universidad Galileo Closure() de un conjunto de ítems Closure encuentra todos los ítems en el mismo “estado” Algoritmo para closure(I) –Todo ítem en I es también un ítem en closure(I) –Si A   B  está en closure(I) y B   es un ítem, entonces agregamos B   a closure(I) –Repetir hasta que no se puedan agregar más ítems a closure(I)

Oscar Bonilla 313Universidad Galileo Ejemplo de Closure Encontrar closure(  ( ) ) Items  $  ( )

Oscar Bonilla 314Universidad Galileo Pregunta: Encuentren Closure Encuentren closure(  $ ) Items  $  ( ) ????

Oscar Bonilla 315Universidad Galileo Pregunta: Encuentren Closure Encuentren closure(  $ ) Items  $  ( )  $  ( )

Oscar Bonilla 316Universidad Galileo Goto() de un conjunto de ítems Goto encuentra el nuevo estado después de consumir un símbolo de la gramática mientras estamos en el estado actual Algoritmo para goto(I, X) donde I es un conjunto de ítems y X es un símbolo de la gramática goto(I, X) = closure( { A   X  | A   X  en I } ) Goto es el nuevo conjunto obtenido al “mover el punto” sobre X

Oscar Bonilla 317Universidad Galileo Ejemplo de Goto Encontrar goto(  ( ), ) Items  $  ( )

Oscar Bonilla 318Universidad Galileo Pregunta: Encuentren goto Encuentren goto(  ( ), ( ) Items  $  ( ) ????

Oscar Bonilla 319Universidad Galileo Pregunta: Encuentren goto Encuentren goto(  ( ), ( ) Items  $  ( )

Oscar Bonilla 320Universidad Galileo Comenzamos con la producción  $ El primer estado es closure(  $ ) Elegimos un estado I –Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, creamos uno Agregamos una arista X del estado I al estado goto(I, X) Repetimos hasta que no sea posible agregar nada más Construyendo los estados del DFA

Oscar Bonilla 321Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más

Oscar Bonilla 322Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más

Oscar Bonilla 323Universidad Galileo  $ Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más

Oscar Bonilla 324Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $

Oscar Bonilla 325Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( )

Oscar Bonilla 326Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0

Oscar Bonilla 331Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0 goto(, )

Oscar Bonilla 332Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ goto(, )

Oscar Bonilla 333Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $

Oscar Bonilla 334Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1

Oscar Bonilla 335Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1

Oscar Bonilla 336Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X

Oscar Bonilla 339Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X goto(, ( )

Oscar Bonilla 340Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X  ( ) goto(, ( )

Oscar Bonilla 343Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X  ( )

Oscar Bonilla 344Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X  ( ) s2

Oscar Bonilla 345Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X  ( ) s2

Oscar Bonilla 346Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X  ( ) s2 (

Oscar Bonilla 349Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X  ( ) s2 ( goto(, ( )

Oscar Bonilla 350Universidad Galileo Ejemplo de construcción de los estados del DFA Comenzar con la producción  $ Crear el primer estado como closure(  $) Elegir un estado I Para cada A   X  en I encontrar goto(I, X) si goto(I, X) no es ya un estado, crear uno Agregar una arista X del estado I al estado goto(I, X) Repetir hasta que no sea posible agregar nada más  $  ( ) s0  $ s1 X  ( ) s2 ( goto(, ( ) El mismo de la vez pasada

Oscar Bonilla 356Universidad Galileo Ejemplo de construcción de los estados del DFA  $  ( ) s0  $ s1 X  ( ) s2 (

Oscar Bonilla 357Universidad Galileo Ejemplo de construcción de los estados del DFA  $  ( ) s0  $ s1 X  ( ) s2 (  ( ) X s3

Oscar Bonilla 358Universidad Galileo Ejemplo de construcción de los estados del DFA  $  ( ) s0  $ s1 X  ( ) s2 (  ( ) X s3 (

Oscar Bonilla 359Universidad Galileo Ejemplo de construcción de los estados del DFA  $  ( ) s0  $ s1 X  ( ) s2 (  ( ) X s3 (  ( ) ) s5

Oscar Bonilla 362Universidad Galileo Ejemplo de construcción de los estados del DFA  $  ( ) s0  $ s1 X  ( ) s2 (  ( ) X s3 (  ( ) ) s5  ( ) ) s4

Oscar Bonilla 365Universidad Galileo Construyendo un Parser Engine LR(0) Construir un DFA –HECHO Construir una tabla de parseo usando el DFA

Oscar Bonilla 366Universidad Galileo Creando las tablas de parseo Para cada estado Transición a otro estado usando un símbolo terminal es un shift a ese estado (shift to sn) Transición a otro estado usando un no-terminal es un goto a ese estado (goto sn) Si hay un ítem A   en el estado hacemos una reducción con esa producción para todos los terminales (reduce k)

Oscar Bonilla 367Universidad Galileo Ejemplo de Construcción de Parse Table  $  ( ) s0  $ s1 X  ( ) s2 (  ( ) X s3 (  ( ) ) s5  ( ) ) s4

Oscar Bonilla 371Universidad Galileo Ejemplo de Construcción de Parse Table s0  $ s1 X  ( ) s2 (  ( ) X s3 (  ( ) ) s5  ( ) ) s4  $  ( )

Oscar Bonilla 375Universidad Galileo Ejemplo de Construcción de Parse Table  $  ( ) s0 s1 X  ( ) s2 (  ( ) X s3 (  ( ) ) s5  ( ) ) s4  $

Oscar Bonilla 378Universidad Galileo Ejemplo de Construcción de Parse Table  $  ( ) s0 s1 X s2 (  ( ) X s3 (  ( ) ) s5  ( ) ) s4  $  ( )

Oscar Bonilla 383Universidad Galileo Ejemplo de Construcción de Parse Table  $  ( ) s0 s1 X s2 ( X s3 (  ( ) ) s5  ( ) ) s4  $  ( )

Oscar Bonilla 390Universidad Galileo Construcción de un Parse Engine LR(0) Agregamos la producción especial S’  S $ Encontramos los ítems de la CFG Creamos el DFA –Usando las funciones closure y goto Construimos la tabla de parseo LR(0) Parser Engine

Oscar Bonilla 391Universidad Galileo Lecturas El Tigre –Secciones 3.0 a 3.3 El Dragón –Secciones 4.2 a 4.5 y 4.7

Compiladores Parsers Parsers Predictivos, LL(0), LL(k), Parsers shift-reduce, Construcción de un Parser LL(0)

Presentaciones similares

Presentación del tema: "Compiladores Parsers Parsers Predictivos, LL(0), LL(k), Parsers shift-reduce, Construcción de un Parser LL(0)"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Compiladores Parsers Parsers Predictivos, LL(0), LL(k), Parsers shift-reduce, Construcción de un Parser LL(0)

Presentaciones similares

Presentación del tema: "Compiladores Parsers Parsers Predictivos, LL(0), LL(k), Parsers shift-reduce, Construcción de un Parser LL(0)"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback