compiladores: análisis léxico - laboratorio de sistemaslsub.org/comp/slides/s02.lex.pdf · un...

1/25/16, 2:47 PMCompiladores: Análisis léxico - (c)2014 LSUB

of 90http://127.0.0.1:3999/s02.lex.slide#1

Compiladores: Análisis léxicoFrancisco J BallesterosLSUB, URJC



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



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



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



Tokens

Para C, por ejemplo

LPAREN (RPAREN )IF ifIDENT mainSCOL ;PLUS +PLUSEQ +=...



Tokens

Para printf

FMT %DECARG dSTRARG sPCENT %%CHARS ...

Por ejemplo

%d, %%d

Nos da

FMT DECARG CHARS(", ") PCENT CHARS("d")

Entre paréntesis van los lexemas



Tokens

Otro ejemplo

x*2+3

Nos podría dar

VAR("x") MULT NUM(2) ADD NUM(3)



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.



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



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)



Tokens

Podemos meter la pata al definirlos

Por ej, en C++

Vector<Number>cin >> xVector<Vector<Number>>

Es el último?

>>

o?

> >

C++ no lo sabe y por eso no compila



Una calculadora

Expresiones sencillas y no ambiguas tales como...

# esto es un comentario3 + 4( 5 * 3 ) + 434 / 5 / 72 * piabs ( 2 * pi )

Por ahora sólo pi y abs como predefinidos.



Una calculadora

Ya hay dudas:

-32 * -32 - 3

No hay cambio de signo.

- 2*1 // no válido.



Una calculadora: Tokens

NUMLPARENRPARENADDSUBMULDIVPIABS



Una calculadora: Tokens

Valor de los tokens:

NUM -> valor como float con signo

Y el resto nada

LPARENRPARENADDSUBMULDIVPIABS

El comentario lo eliminamos y no es un token



Ejemplo:

# esto es un comentario3 + 4( 5 * 3 ) + 434 / 5 / 72 * piabs ( 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 PIABS LPAREN NUM(2) MUL PI RPAREN



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; }




{ print x; print y; print z; }x = "texto";if x == "texto" { ... }for x in "a" "b" "c" { print x; }

Tokens:

LBRARBRASCOLEQEQEQPRINTFORIFNAMESTR




Valores de los tokens:

NAME -> xSTR -> "texto"

El resto ninguno



Expresiones regulares

Sólo expresiones sencillas

abca|b|c.[0-9]([0-9]|[a-z])*




abca|b|c.[0-9]([0-9]|[a-z])*

Tokens

CHRORANYRANGELPARENRPARENSTAR




Valor de los tokens

CHR -> aRANGE -> 0-9

Y el resto ninguno



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



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.



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}



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]+) // 3 -4 -2.3LPAREN $ // (RPAREN $ // )ADD \+ // +SUB - // -MUL \* // *DIV / // /PI pi // piABS abs // abs

Nos da

(-?[0-9]+(\.[0-9]+))|$|$|\+|-|\*|/|pi|abs



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



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



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 ...



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



Lenguaje para tokens de calculadora

Ejemplo, el lenguaje que describe los tokens de

# esto es un comentario3 + 4.4( 5 * 3 ) + -434 / 5 / 72 * piabs ( 2 * pi )

que son

NUMLPARENRPARENADDSUBMULDIVPIABS

puesto que ignoramos comentarios y espacio y en blanco!



Lenguaje para tokens de calculadora

Podríamos describirlo como la expresión regular

LTC = (-?[0-9]+(\.[0-9]+))|$|$|\+|-|\*|/|pi|abs

que reconoce entre otros...

3+4.4(5*3)+-43abspi



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



Autómata para LTC

Por ejemplo, para

abs

Podríamos definir



Autómata para LTC

O lo que es lo mismo



Autómata para LTC

Y para pi|abs



Autómata para LTC

Por ejemplo, para nuestros números

4 54

Podríamos definir



Autómata para LTC

Y con decimales...

4 54 43.23

Podríamos definir



Autómata para LTC

Y con decimales y signo opcional...

4 54 43.23 -32 -2.3

Podríamos definir



Autómata para LTC

Todo junto



Autómata para LTC

¿Está todo?

No

Nos falta (, ), +, -, * y /

Y tenemos problemas

-3

- 3

Hay algo de ambigüedad.



Ambigüedad

-3

- 3

Podemos decidir entre signo y resta mirando si sigue un dígito o no.



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



No determinismo

Necitamos un atómata finito no determinista

Hay dos transiciones válidas para -



Atómata finito no determinista

Podemos tener transiciones en la cadena vacía para el signo



Autómata para LTC



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



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)



Autómatas para expresiones regulares

NFA para

x




NFA para

re1 re2




NFA para

re1 | re2




NFA para

re1 ?




NFA para

re1 *




NFA para

c(a|b)*




NFA para

c(a|b)*

Y podemos simplificarlo



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 estadosNFA alcanzado

si tenemos un estado final del NFA, el estado es final.



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



¿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!)



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




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




¿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.




Tokens

type TokId inttype Tok struct { Id TokId Num float64}

// token id valuesconst ( None TokId = iota Num Lparen Rparen Add Sub Mul Div Pi Abs)




Lexer

type Lexer interface { // return next token Scan() (Tok, error) // Look ahead one token Peek() (Tok, error)}




Lex

type lex struct { in Text saved Tok}

func NewLex(t Text) Lexer { return &lex{in: t}}




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()}




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 } }}




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)}




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}




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 }}




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 }}




Listo

Ojo a bug en SUB!

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



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()



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



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 } }}



Comentarios

func main() { text := `# comentario3 - (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



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



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




Tokens

type TokId inttype Tok struct { Id TokId Val string Ln int}

// token id valuesconst ( None TokId = iota Str Lbra Rbra Eq Cmp Id Scol Print If For In)




Nuevo lex

type lex struct { in Text saved Tok ln int val []rune}

func NewLex(t Text) Lexer { return &lex{in: t, ln: 1}}




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++ } }}




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()}




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}




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




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




Asignación y comparación


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




Identificadores y keywords

Vamos a usar una tabla de keywords

var keywords = map[string]TokId { "print": Print, "if": If, "for": For, "in": In,}




Identificadores y keywords


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)




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



Questions?

Francisco J BallesterosLSUB, URJChttp://lsub.org (http://lsub.org)

http://lsub.org/

compiladores: análisis léxico - laboratorio de sistemaslsub.org/comp/slides/s02.lex.pdf · un...

Documents