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

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

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

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?

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

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])*

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

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

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?

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

Y tenemos problemas

Hay algo de ambigüedad.

Ambigüedad

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

re1 re2

NFA para

re1 | re2

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)

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

type lex struct { in Text saved Tok}

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

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

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

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

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

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:

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)

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

Documents

poder judicial de la provincia de entre rÍos concurso de...

clase 7: strings · #include #include using namespace...

accesorios para inversor central sunny...

libro lex 2011 - grupo laminex lex.pdf · 2019. 12. 4. ·...

2 strings archivo areglos semana2

slg200n français slg200nw italiano 取扱説明書...

listas - upc universitat politècnica de...

música: adagio for strings

nylon strings model slg200nw - es.yamaha.com · muchas...

lenguaje escrito. campo formativo: lenguaje y comunicación...

funciones de strings en php

repaso/resumen introducción a la programación orientada a...

dw03 ctes web - 05 - strings y archivos

strings de instrumentacion virtual

projecte nails&strings

computação 1 - python aula 4 - teórica: variáveis e...

coa gl strings

contenido -...

funciones de cadena (strings)

nguyenthoai.files.wordpress.com...flute £ £ £ clarinet £...