Compiladores: Análisis léxico

Transcripción

1 Compiladores: Análisis léxico Francisco J Ballesteros LSUB, URJC Page 1 of 90

2 Analizador léxico Identificar tokens en la cadena de entrada procesar los ficheros de entrada generar la entrada para el parser Ignorar comentarios Mantener la idea de fichero-número de línea para mensajes de error Page 2 of 90

3 Analizador léxico Al definir el lenguaje tendremos que definir una gramática para el mismo Los elementos básicos de la gramática son los tokens Page 3 of 90

4 Analizador léxico Token palabras reservadas identificadores números signos de puntuación El conjunto de tokens depende del lenguaje en cuestión Usaremos palabras reservadas en el análisis sintáctico Normalmente ignoramos el espacio en blanco El valor de un token o lexema es el string para el mismo Page 4 of 90

5 Tokens Para C, por ejemplo LPAREN ( RPAREN ) IF if IDENT main SCOL ; PLUS + PLUSEQ +=... Page 5 of 90

6 Tokens Para printf FMT % DECARG d STRARG s PCENT %% CHARS... Por ejemplo %d, %%d Nos da FMT DECARG CHARS(", ") PCENT CHARS("d") Entre paréntesis van los lexemas Page 6 of 90

7 Tokens Otro ejemplo x*2+3 Nos podría dar VAR("x") MULT NUM(2) ADD NUM(3) Page 7 of 90

8 Tokens Otro ejemplo pi*2+3 Nos podría dar PI MULT NUM(2) ADD NUM(3) Esta vez pi no es una variable, está reservado. Page 8 of 90

9 Tokens Otro ejemplo, expresiones regulares: [ab]+.*\.c$ Podríamos tener los tokens LBRA CHR('a') CHR('b') RBRA PLUS DOT STAR CHR('.') CHR('c') ETEXT O tal vez LBRA STR("ab") RBRA PLUS DOT STAR STR(".c") ETEXT O tal vez SET("ab") PLUS DOT STAR CHR('.') CHR('c') ETEXT Todo depende de cómo hagamos el lenguaje Page 9 of 90

10 Tokens Un token tiene identificador único (ID, LBRA, RBRA,...) lexema o valor (3.5, main,...) Muchas veces fichero y número de línea (para errores) Page 10 of 90

11 Tokens Podemos meter la pata al definirlos Por ej, en C++ Vector<Number> cin >> x Vector<Vector<Number>> Es el último? >> o? > > C++ no lo sabe y por eso no compila Page 11 of 90

12 Una calculadora Expresiones sencillas y no ambiguas tales como... # esto es un comentario ( 5 * 3 ) / 5 / 7 2 * pi abs ( 2 * pi ) Por ahora sólo pi y abs como predefinidos. Page 12 of 90

13 Una calculadora Ya hay dudas: -3 2 * No hay cambio de signo. - 2*1 // no válido. Page 13 of 90

14 Una calculadora: Tokens NUM LPAREN RPAREN ADD SUB MUL DIV PI ABS Page 14 of 90

15 Una calculadora: Tokens Valor de los tokens: NUM -> valor como float con signo Y el resto nada LPAREN RPAREN ADD SUB MUL DIV PI ABS El comentario lo eliminamos y no es un token Page 15 of 90

16 Ejemplo: # esto es un comentario ( 5 * 3 ) / 5 / 7 2 * pi abs ( 2 * pi ) nos da NUM(3) ADD NUM(4) LPAREN NUM(5) MUL NUM(3) RPAREN ADD NUM(43) NUM(4) DIV NUM(5) DIV NUM(7) NUM(2) MUL PI ABS LPAREN NUM(2) MUL PI RPAREN Page 16 of 90

17 Un trozo de un lenguaje Sentencias sencillas { print x; print y; print z; x = "texto"; if x == "texto" {... for x in "a" "b" "c" { print x; Page 17 of 90

18 Un trozo de un lenguaje { print x; print y; print z; x = "texto"; if x == "texto" {... for x in "a" "b" "c" { print x; Tokens: LBRA RBRA SCOL EQ EQEQ PRINT FOR IF NAME STR Page 18 of 90

19 Un trozo de un lenguaje Valores de los tokens: NAME -> x STR -> "texto" El resto ninguno Page 19 of 90

20 Expresiones regulares Sólo expresiones sencillas abc a b c. [0-9] ([0-9] [a-z])* Page 20 of 90

21 Expresiones regulares abc a b c. [0-9] ([0-9] [a-z])* Tokens CHR OR ANY RANGE LPAREN RPAREN STAR Page 21 of 90

22 Expresiones regulares Valor de los tokens CHR -> a RANGE -> 0-9 Y el resto ninguno Page 22 of 90

23 Construcción de un scanner Tenemos que pasar de texto a tokens leyendo de izquierda a derecha normalmente se permite mirar un char adelante cada token corresponde a un string hay que ver hasta dónde llega cada uno Page 23 of 90

24 Construcción de un scanner Podríamos describir cada token con una expresión regular teniendo cuidado de evitar ambigüedad probar en cada punto de la entrada cada expresión devolver el token que encaja con la expresión En esto se basa lex(1), pero es más fácil. Page 24 of 90

25 Lenguajes y alfabetos Un lenguaje es un conjunto de strings (los válidos en el lenguaje) Los strings son secuencias de símbolos de un alfabeto No todos los strings pertenecen al lenguaje A = {símbolos válidos en el lenguaje L(A) = {strings de A válidos Page 25 of 90

26 Tokens, lenguajes y alfabetos Para tener un scanner podemos definir un lenguaje para los lexemas lexema: "valor" de los tokens Por ejemplo NUM -?[0-9]+(\.[0-9]+) // LPAREN \( // ( RPAREN \) // ) ADD \+ // + SUB - // - MUL \* // * DIV / // / PI pi // pi ABS abs // abs Nos da (-?[0-9]+(\.[0-9]+)) \( \) \+ - \* / pi abs Page 26 of 90

27 Tokens, lenguajes y alfabetos En este lenguaje podemos reconocer las cadenas sin depender del contexto en que están empleando expresiones regulares Es un lenguaje regular Page 27 of 90

28 Lenguajes y autómatas Un atómata finito es una máquina que acepta cadenas Un lenguaje regular es reconocible por un atómata finito Un lenguaje regular es describible con una expresión regular Una expresión regular es implementable con un autómata finito Page 28 of 90

29 Expresión regular Definida recursivamente Siendo x un char y a y b expresiones regulares: L(x) = { x, siendo x cualquier char salvo \, (, ),.,, *,? L(\x) = { x L((a)) = L(a) L(.) = { cualquier char L(ab) = { la de L(a) concatenado con lb de L(b) L(a b) = L(a) U L(b) L(a*) = { "" U L(a) U L(aa) U L(aaa) U... Page 29 of 90

30 Autómata finito En este lenguaje podemos reconocer las cadenas utilizando un autómata finito Para reconocerlo: partimos de un estado inicial en cada carácter de la entrada transitamos a otro estado algunos de los estados son finales si terminamos y no hay estado final, tenemos un error Un error es una cadena no reconocida Page 30 of 90

31 Lenguaje para tokens de calculadora Ejemplo, el lenguaje que describe los tokens de # esto es un comentario ( 5 * 3 ) / 5 / 7 2 * pi abs ( 2 * pi ) que son NUM LPAREN RPAREN ADD SUB MUL DIV PI ABS puesto que ignoramos comentarios y espacio y en blanco! Page 31 of 90

32 Lenguaje para tokens de calculadora Podríamos describirlo como la expresión regular LTC = (-?[0-9]+(\.[0-9]+)) \( \) \+ - \* / pi abs que reconoce entre otros ( 5 * 3 ) abs pi Page 32 of 90

33 Autómata para LTC Para definir un atómata finito partimos de un estado inicial para cada estado y símbolo en la entrada transitamos a otro estado indicamos qué estados son finales Si no está definida una transición, no reconocemos ese caso. El automáta es: alfabeto de entrada conjunto de estados (con inicial y finales) conjunto de transiciones Page 33 of 90

34 Autómata para LTC Por ejemplo, para abs Podríamos definir Page 34 of 90

35 Autómata para LTC O lo que es lo mismo Page 35 of 90

36 Autómata para LTC Y para pi abs Page 36 of 90

37 Autómata para LTC Por ejemplo, para nuestros números 4 54 Podríamos definir Page 37 of 90

38 Autómata para LTC Y con decimales Podríamos definir Page 38 of 90

39 Autómata para LTC Y con decimales y signo opcional Podríamos definir Page 39 of 90

40 Autómata para LTC Todo junto Page 40 of 90

41 Autómata para LTC Está todo? No Nos falta (, ), +, -, * y / Y tenemos problemas -3-3 Hay algo de ambigüedad. Page 41 of 90

42 Ambigüedad -3-3 Podemos decidir entre signo y resta mirando si sigue un dígito o no. Page 42 of 90

43 Ambigüedad En general podemos Utilizar la cadena más larga que encaja Utilizar la primera de las subexpresiones si hay varias En nuestro ejemplo en realidad no hay ambigüedad: hay no determinismo Page 43 of 90

44 No determinismo Necitamos un atómata finito no determinista Hay dos transiciones válidas para - Page 44 of 90

45 Atómata finito no determinista Podemos tener transiciones en la cadena vacía para el signo Page 45 of 90

46 Autómata para LTC Page 46 of 90

47 Scan de nombres En lugar de utilizar estados para reconocer todos los nombres Podemos reconocer un nombre en general Y buscar el nombre en una tabla para ver si está reservado Esto se hace si hay muchas palabras reservadas (keywords) O si son varias pero son largas Page 47 of 90

48 Autómatas Finitos Deterministas (AFD, o DFA) una única transición por estado y entrada Finitos no deterministas (AFND, o NFA) varias transiciones posibles transiciones con la cadena vacía (se puede transitar o no) Page 48 of 90

49 Autómatas para expresiones regulares NFA para x Page 49 of 90

50 Autómatas para expresiones regulares NFA para re1 re2 Page 50 of 90

51 Autómatas para expresiones regulares NFA para re1 re2 Page 51 of 90

52 Autómatas para expresiones regulares NFA para re1? Page 52 of 90

53 Autómatas para expresiones regulares NFA para re1 * Page 53 of 90

54 Autómatas para expresiones regulares NFA para c(a b)* Page 54 of 90

55 Autómatas para expresiones regulares NFA para c(a b)* Y podemos simplificarlo Page 55 of 90

56 Construir un DFA desde un NFA Es fácil pero tedioso: los estados del DFA son los conjuntos de estados alcanzados en el NFA empezar en el estado inicial del NFA para cada posible transición NFA: transitar al estado del DFA para el cjto de estados NFA alcanzado si tenemos un estado final del NFA, el estado es final. Page 56 of 90

57 Implementar un DFA Podemos utilizar una tabla Columnas para los estados Filas para la entradas Nuevos estados como valores La función de estado toma una entrada y devuelve el nuevo estado Hasta que la entrada se acepta Page 57 of 90

58 Dónde estábamos? Queríamos un scanner para la calculadora Y para eso hicimos un NFA para el lenguaje de sus tokens (que a su vez son tokens de otro lenguaje!) Page 58 of 90

59 Scanner para la calculadora Page 59 of 90

60 Scanner para la calculadora Podemos implementar directamente el autómata Usando lex(1) y dándole las expresiones regulares o mejor escribiendo en Go el código para el autómata si hay muchos nombres usaríamos una tabla. va a quedar pequeño y rápido Page 60 of 90

61 Scanner para la calculadora Primero la entrada... var text = `3 + (4.3 * abs(-1 * pi))` func main() { fmt.printf("scanning %s\n", text) txt := NewStrText(text) for { r, err := txt.get() if err!= nil { fmt.printf("got err %s\n", err) break fmt.printf("got %c\n", r) Run Page 61 of 90

62 Scanner para la calculadora Qué es la entrada para nosotros? type Text interface { Get() (rune, error) Unget() error Utilizaremos Unget para look-ahead De hecho, go tiene un interface (io.runescanner) definido para esto. Page 62 of 90

63 Scanner para la calculadora Tokens type TokId int type Tok struct { Id TokId Num float64 // token id values const ( None TokId = iota Num Lparen Rparen Add Sub Mul Div Pi Abs ) Page 63 of 90

64 Scanner para la calculadora Lexer type Lexer interface { // return next token Scan() (Tok, error) // Look ahead one token Peek() (Tok, error) Page 64 of 90

65 Scanner para la calculadora Lex type lex struct { in Text saved Tok func NewLex(t Text) Lexer { return &lex{in: t Page 65 of 90

66 Scanner para la calculadora Lex func (l *lex) Peek() (Tok, error) { tok, err := l.scan() l.saved = tok return tok, err func (l *lex) Scan() (Tok, error) { if l.saved.id!= None { x := l.saved l.saved = Tok{ return x, nil if err := l.skipblanks(); err!= nil { return Tok{, err return l.nexttok() Page 66 of 90

67 Scanner para la calculadora Lex func (l *lex) skipblanks() error { for { c, err := l.in.get() if err!= nil { return err if c!= ' ' && c!= '\t' && c!= '\n' { l.in.unget() return nil Page 67 of 90

68 Scanner para la calculadora Lex func (l *lex) nexttok() (Tok, error) { c, err := l.in.get() if err!= nil { return Tok{, err switch { case c == '+': return Tok{Id:Add, nil case c == '-': return Tok{Id:Sub, nil case c == '*': return Tok{Id:Mul, nil case c == '/': return Tok{Id:Div, nil case c >= '0' && c <= '9': l.in.unget() return l.scannum() case c == 'p': l.in.unget() return l.scanpi() case c == 'a': l.in.unget() return l.scanabs() return Tok{, fmt.errorf("wrong input at char %c", c) Page 68 of 90

69 Scanner para la calculadora Lex, números func (l *lex) scannum() (Tok, error) { n, err := l.scanint() if err!= nil { return Tok{, err c, err := l.in.get() if err!= nil { return Tok{Id: Num, Num: n, nil if c!= '.' { l.in.unget() return Tok{Id: Num, Num: n, nil dec, err := l.scandec() if err!= nil { return Tok{, err return Tok{Id: Num, Num: n+dec, nil Page 69 of 90

70 Scanner para la calculadora Lex, números func (l *lex) scanint() (float64, error) { r := 0.0 some := false for { c, err := l.in.get() if some && err == io.eof { return r, nil if err!= nil { return r, err if c <= '0' c >= '9' { l.in.unget() return r, nil r *= 10 r += float64(int(c) - int('0')) some = true Page 70 of 90

71 Scanner para la calculadora Lex, números func (l *lex) scandec() (float64, error) { r := 0.0 d := 1.0 some := false for { c, err := l.in.get() if some && err == io.eof { return r, nil if err!= nil { return r, err if c <= '0' c >= '9' { l.in.unget() return r, nil n := int(c) - int('0') r += float64(n) / d d *= 10.0 some = true Page 71 of 90

72 Scanner para la calculadora Listo func main() { text := `3 + (41.32 * abs(-1 * pi))` fmt.printf("scanning %s\n", text) txt := NewStrText(text) l := NewLex(txt) for { t, err := l.scan() if err!= nil { fmt.printf("got err %s\n", err) break fmt.printf("got tok %s\tnum %v\n", t.id, t.num) Run Ojo a bug en SUB! Page 72 of 90

73 Scanner para la calculadora: fixed func (l *lex) nexttok() (Tok, error) { c, err := l.in.get() if err!= nil { return Tok{, err switch { case c == '+': return Tok{Id:Add, nil case c == '-': n, _ := l.in.get() l.in.unget() if n >= '0' && n <= '9' { t, err := l.scannum() t.num *= -1 return t, err return Tok{Id:Sub, nil case c == '*': return Tok{Id:Mul, nil case c == '/': return Tok{Id:Div, nil case c == '(': return Tok{Id:Lparen, nil case c == ')': return Tok{Id:Rparen, nil case c >= '0' && c <= '9': l.in.unget() return l.scannum() case c == 'p': l.in.unget() Page 73 of 90

74 Scanner para la calculadora: fixed Y ahora func main() { text := `3 - (41.32 * abs(-1 * pi))` fmt.printf("scanning %s\n", text) txt := NewStrText(text) l := NewLex(txt) for { t, err := l.scan() if err!= nil { fmt.printf("got err %s\n", err) break fmt.printf("got tok %s\tnum %v\n", t.id, t.num) Run Page 74 of 90

75 Comentarios func (l *lex) skipblanks() error { for { c, err := l.in.get() if err!= nil { return err if c == '#' { for c!= '\n' { if c, err = l.in.get(); err!= nil { return err if c!= ' ' && c!= '\t' && c!= '\n' { l.in.unget() return nil Page 75 of 90

76 Comentarios func main() { text := ` # comentario 3 - (41.32 * abs(-1 * pi)) ` fmt.printf("scanning %s\n", text) txt := NewStrText(text) l := NewLex(txt) for { t, err := l.scan() if err!= nil { fmt.printf("got err %s\n", err) break fmt.printf("got tok %s\tnum %v\n", t.id, t.num) Run Page 76 of 90

77 Comentarios La parte delicada es reconocerlos sin que sea ambiguo si es otro token. a / b vs a // b Se hace que el autómata se coma todo desde el token de principio de comentario hasta el de fin de comentario Page 77 of 90

78 Scanner para sentencias sencillas # comentario { print x; print y; print z; x = "texto"; if x == "texto" {... for x in "a" "b" "c" { print x; Esta vez mantendremos nombre de fichero y número de línea Y guardaremos el lexema Page 78 of 90

79 Scanner para sentencias sencillas Tokens type TokId int type Tok struct { Id TokId Val string Ln int // token id values const ( None TokId = iota Str Lbra Rbra Eq Cmp Id Scol Print If For In ) Page 79 of 90

80 Scanner para sentencias sencillas Nuevo lex type lex struct { in Text saved Tok ln int val []rune func NewLex(t Text) Lexer { return &lex{in: t, ln: 1 Page 80 of 90

81 Scanner para sentencias sencillas SkipBlanks cuenta líneas ahora func (l *lex) skipblanks() error { for { c, err := l.in.get() if err!= nil { return err if c == '#' { for c!= '\n' { if c, err = l.in.get(); err!= nil { return err if c == '\n' { l.ln++ if c!= ' ' && c!= '\t' && c!= '\n' { l.in.unget() return nil if c == '\n' { l.ln++ Page 81 of 90

82 Scanner para sentencias sencillas Scan y peek como antes func (l *lex) Peek() (Tok, error) { tok, err := l.scan() l.saved = tok return tok, err func (l *lex) Scan() (Tok, error) { if l.saved.id!= None { x := l.saved l.saved = Tok{ return x, nil if err := l.skipblanks(); err!= nil { return Tok{, err return l.nexttok() Page 82 of 90

83 Scanner para sentencias sencillas NextTok es nuestro scanner utilizando got para acumular caracteres que nos gustan y tambien gottok para terminar con el token actual func (l *lex) got(r rune) { l.val = append(l.val, r) func (l *lex) gottok(id TokId) Tok { t := Tok{ Id: id, Val: string(l.val), Ln: l.ln, l.val = nil return t Page 83 of 90

84 Scanner para sentencias sencillas La parte fácil func (l *lex) nexttok() (Tok, error) { c, err := l.in.get() if err!= nil { return Tok{, err switch { case c == '{': l.got('{'); return l.gottok(lbra), nil case c == '': l.got(''); return l.gottok(rbra), nil case c == ';': l.got(';'); return l.gottok(scol), nil Page 84 of 90

85 Scanner para sentencias sencillas Los strings... func (l *lex) nexttok() (Tok, error) { c, err := l.in.get() if err!= nil { return Tok{, err switch { case c == '"': for { c, err := l.in.get() if err!= nil { return Tok{, err if c == '"' { return l.gottok(str), nil l.got(c) //str Page 85 of 90

86 Scanner para sentencias sencillas Asignación y comparación func (l *lex) nexttok() (Tok, error) { c, err := l.in.get() if err!= nil { return Tok{, err switch { case c == '=': l.got('=') n, _ := l.in.get() if n == '=' { l.got('=') return l.gottok(cmp), nil l.in.unget() return l.gottok(eq), nil Page 86 of 90

87 Scanner para sentencias sencillas Identificadores y keywords Vamos a usar una tabla de keywords var keywords = map[string]tokid { "print": Print, "if": If, "for": For, "in": In, Page 87 of 90

88 Scanner para sentencias sencillas Identificadores y keywords func (l *lex) nexttok() (Tok, error) { c, err := l.in.get() if err!= nil { return Tok{, err switch { case unicode.isletter(c): l.got(c) for { c, err := l.in.get() if err!= nil { return Tok{, err if!unicode.isletter(c) &&!unicode.isnumber(c) { l.in.unget() t := l.gottok(id) if id, ok := keywords[t.val]; ok { t.id = id return t, nil l.got(c) Page 88 of 90

89 Scanner para sentencias sencillas Y listo: var keywords = map[string]tokid { "print": Print, "if": If, "for": For, "in": In, var text = ` { print x; print y; print z; x = "texto"; if x == "texto" { print xxx; for x in "a" "b" "c" { print x; ` func main() { fmt.printf("scanning %s\n", text) txt := NewStrText(text) l := NewLex(txt) for { t, err := l.scan() if err!= nil { fmt.printf("got err %s\n", err) break fmt.printf("ln %d tok %s\t '%v'\n", t.ln, t.id, t.val) Run Page 89 of 90

90 Questions? Francisco J Ballesteros LSUB, URJC ( Page 90 of 90