Apuntes de la Asignatura Procesadores de Lenguajes

Apuntes de la Asignatura Procesadores de Lenguajes
Casiano R. Le´on
1
10 de febrero de 2015
1
DEIOC Universidad de La Laguna
´Indice general
I
PARTE: APUNTES DE PROCESADORES DE LENGUAJES
1. Expresiones Regulares y An´
alisis L´
exico en JavaScript
1.1. Mozilla Developer Network: Documentaci´
on . . . . . . . . . . . .
1.2. Pr´actica: Conversor de Temperaturas . . . . . . . . . . . . . . . .
1.3. Pr´actica: Comma Separated Values. CSV . . . . . . . . . . . . .
1.4. Comentarios y Consejos . . . . . . . . . . . . . . . . . . . . . . .
1.5. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6. Pr´actica: Palabras Repetidas . . . . . . . . . . . . . . . . . . . .
1.7. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.8. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.9. Pr´actica: Ficheros INI . . . . . . . . . . . . . . . . . . . . . . . .
1.10. Pr´actica: Analizador L´exico para Un Subconjunto de JavaScript
8
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
9
9
32
52
53
56
60
60
60
68
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
Traducci´on
. . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
71
71
72
72
72
77
77
78
78
79
3. An´
alisis Sint´
actico Mediante Precedencia de Operadores en JavaScript
3.1. Ejemplo Simple de Int´erprete: Una Calculadora . . . . . . . . . . . . . . . . . . . . . .
3.2. An´
alisis Top Down Usando Precedencia de Operadores . . . . . . . . . . . . . . . . . .
3.2.1. Gram´atica de JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
83
83
83
4. An´
alisis Descendente mediante Parsing Expresion Grammars en JavaScript
4.1. Introducci´
on a los PEGs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1. Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.2. Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.3. Implementing parsers from parsing expression grammars . . . . . . . . . .
4.1.4. Lexical Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.5. Left recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.6. Referencias y Documentaci´
on . . . . . . . . . . . . . . . . . . . . . . . . .
4.2. PEGJS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3. Un Ejemplo Sencillo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.1. Asociaci´
on Incorrecta para la Resta y la Divisi´
on . . . . . . . . . . . . . .
4.4. Acciones Intermedias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5. PegJS en los Browser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6. Eliminaci´
on de la Recursividad por la Izquierda en PEGs . . . . . . . . . . . . .
84
84
84
85
85
86
86
86
86
90
92
92
93
96
2. Analizadores Descendentes Predictivos en JavaScript
2.1. Conceptos B´
asicos para el An´
alisis Sint´actico . . . . . . . . . .
2.1.1. Ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2. An´
alisis Sint´actico Predictivo Recursivo . . . . . . . . . . . . .
2.2.1. Introducci´
on . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2. Ejercicio: Recorrido del ´
arbol en un ADPR . . . . . . .
2.3. Recursi´
on por la Izquierda . . . . . . . . . . . . . . . . . . . . .
2.4. Esquemas de Traducci´on . . . . . . . . . . . . . . . . . . . . . .
2.5. Eliminaci´
on de la Recursi´
on por la Izquierda en un Esquema de
2.6. Pr´actica: Analizador Descendente Predictivo Recursivo . . . . .
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4.7. Eliminando la Recursividad por la Izquierda en la Calculadora . . . . . . . . . . .
4.8. Eliminaci´
on de la Recursividad por la Izquierda y Atributos Heredados . . . . . . .
4.8.1. Eliminaci´
on de la Recursi´
on por la Izquierda en la Gram´atica . . . . . . . .
4.8.2. Eliminaci´
on de la Recursi´
on por la Izquierda en un Esquema de Traducci´on
4.8.3. Eliminaci´
on de la Recursividad por la Izquierda en PEGJS . . . . . . . . .
4.9. Dangling else: Asociando un else con su if mas cercano . . . . . . . . . . . . . . . .
4.10. Not Predicate: Comentarios Anidados . . . . . . . . . . . . . . . . . . . . . . . . .
4.11. Un Lenguaje Dependiente del Contexto . . . . . . . . . . . . . . . . . . . . . . . .
4.12. Usando Pegjs con CoffeeScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.13. Pr´actica: Analizador de PL0 Ampliado Usando PEG.js . . . . . . . . . . . . . . . .
4.14. Pr´actica: Ambiguedad en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.15. Pr´actica: Inventando un Lenguaje: Tortoise . . . . . . . . . . . . . . . . . . . . . .
5. An´
alisis Sint´
actico Ascendente en JavaScript
5.1. Conceptos B´
asicos para el An´
alisis Sint´actico . . . . . . . . . . . .
5.1.1. Ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2. Ejemplo Simple en Jison . . . . . . . . . . . . . . . . . . . . . . . .
5.2.1. V´ease Tambi´en . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.2. Pr´
actica: Secuencia de Asignaciones Simples . . . . . . . . .
5.3. Ejemplo en Jison: Calculadora Simple . . . . . . . . . . . . . . . .
5.3.1. Pr´
actica: Calculadora con Listas de Expresiones y Variables
5.4. Conceptos B´
asicos del An´
alisis LR . . . . . . . . . . . . . . . . . .
5.5. Construcci´on de las Tablas para el An´
alisis SLR . . . . . . . . . .
5.5.1. Los conjuntos de Primeros y Siguientes . . . . . . . . . . .
5.5.2. Construcci´on de las Tablas . . . . . . . . . . . . . . . . . .
5.6. Pr´actica: Analizador de PL0 Usando Jison . . . . . . . . . . . . . .
´
5.7. Pr´actica: An´
alisis de Ambito
en PL0 . . . . . . . . . . . . . . . . .
5.8. Pr´actica: Traducci´on de Infijo a Postfijo . . . . . . . . . . . . . . .
5.9. Pr´actica: Calculadora con Funciones . . . . . . . . . . . . . . . . .
´
5.10. Pr´actica: Calculadora con An´
alisis de Ambito
. . . . . . . . . . . .
5.11. Algoritmo de An´
alisis LR . . . . . . . . . . . . . . . . . . . . . . .
5.12. El m´
odulo Generado por jison . . . . . . . . . . . . . . . . . . . .
5.12.1. Version . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.12.2. Gram´atica Inicial . . . . . . . . . . . . . . . . . . . . . . . .
5.12.3. Tablas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.12.4. Acciones Sem´anticas . . . . . . . . . . . . . . . . . . . . . .
5.12.5. Tabla de Acciones y GOTOs . . . . . . . . . . . . . . . . .
5.12.6. defaultActions . . . . . . . . . . . . . . . . . . . . . . . . .
5.12.7. Reducciones . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.12.8. Desplazamientos/Shifts . . . . . . . . . . . . . . . . . . . .
5.12.9. Manejo de Errores . . . . . . . . . . . . . . . . . . . . . . .
5.12.10.Analizador L´exico . . . . . . . . . . . . . . . . . . . . . . .
5.12.11.Exportaci´
on . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.13. Precedencia y Asociatividad . . . . . . . . . . . . . . . . . . . . . .
5.14. Esquemas de Traducci´on . . . . . . . . . . . . . . . . . . . . . . . .
5.15. Manejo en jison de Atributos Heredados . . . . . . . . . . . . . .
5.16. Definici´on Dirigida por la Sint´axis . . . . . . . . . . . . . . . . . .
5.17. Ejercicios: Casos de Estudio . . . . . . . . . . . . . . . . . . . . . .
5.17.1. Un mal dise˜
no . . . . . . . . . . . . . . . . . . . . . . . . .
5.17.2. Gram´atica no LR(1) . . . . . . . . . . . . . . . . . . . . . .
5.17.3. Un Lenguaje Intr´ınsecamente Ambiguo . . . . . . . . . . .
5.17.4. Conflicto reduce-reduce . . . . . . . . . . . . . . . . . . . .
5.18. Recuperaci´on de Errores . . . . . . . . . . . . . . . . . . . . . . . .
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
99
100
100
101
101
102
104
105
106
107
107
109
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
111
111
112
112
115
115
115
120
120
123
123
124
130
131
132
132
133
137
138
138
138
138
139
141
141
142
143
144
145
147
149
154
155
158
160
160
161
161
162
168
5.19. Depuraci´on en jison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
´
5.20. Construcci´on del Arbol
Sint´actico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
5.21. Consejos a seguir al escribir un programa jison . . . . . . . . . . . . . . . . . . . . . . 169
6. An´
alisis Sint´
actico Ascendente en Ruby
6.1. La Calculadora . . . . . . . . . . . . . .
6.1.1. Uso desde L´ınea de Comandos .
6.1.2. An´
alisis L´exico con rexical . . .
6.1.3. An´
alisis Sint´actico . . . . . . . .
6.2. V´ease Tambi´en . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
´
7. Transformaciones Arbol
´
7.1. Arbol de An´
alisis Abstracto . . . . . . . . . . . . . . . . . . . .
´
7.2. Selecci´
on de C´
odigo y Gram´aticas Arbol
. . . . . . . . . . . . .
´
´
7.3. Patrones Arbol y Transformaciones Arbol . . . . . . . . . . . .
´
7.4. Ejemplo de Transformaciones Arbol:
Parse::Eyapp::TreeRegexp
7.5. Treehugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
´
7.6. Pr´actica: Transformaciones en Los Arboles
del Analizador PL0
II
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
170
170
170
171
171
173
.
.
.
.
.
.
174
174
177
179
181
186
188
PARTE: CREATE YOUR OWN PROGRAMMING LANGUAGE
189
8. JavaScript Review
191
8.1. Closures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
9. Your First Compiler
192
10.Parsing
193
11.Scheem Interpreter
11.1. Scheem Interpreter . . . . . .
11.2. Variables . . . . . . . . . . .
11.3. Setting Values . . . . . . . . .
11.4. Putting Things Together . . .
11.4.1. Unit Testing: Mocha .
11.4.2. Grunt . . . . . . . . .
11.4.3. GitHub Project Pages
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
194
194
194
194
194
194
197
201
12.Functions and all that
203
13. Inventing a language for turtle graphics
204
III
205
PARTE: HERRAMIENTAS
3
´Indice de figuras
1.1. Ejemplo de pantalla de La aplicaci´on para el An´
alisis de Datos en Formato CSV . . .
33
4.1. pegjs en la web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
96
5.1. NFA que reconoce los prefijos viables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
5.2. DFA equivalente al NFA de la figura 5.1 . . . . . . . . . . . . . . . . . . . . . . . . . . 125
5.3. DFA construido por Jison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
4
´Indice de cuadros
2.1. Una Gram´atica Simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
73
A Juana
For it is in teaching that we learn
And it is in understanding that we are understood
6
Agradecimientos/Acknowledgments
A mis alumnos de Procesadores de Lenguajes del Grado de Inform´atica de la Escuela
Superior de Inform´atica en la Universidad de La Laguna
7
Parte I
PARTE: APUNTES DE
PROCESADORES DE LENGUAJES
8
Cap´ıtulo 1
Expresiones Regulares y An´
alisis
L´
exico en JavaScript
1.1.
Mozilla Developer Network: Documentaci´
on
1. RegExp Objects
2. exec
3. search
4. match
5. replace
1.2.
Pr´
actica: Conversor de Temperaturas
V´ease https://bitbucket.org/casiano/pl-grado-temperature-converter/src.
[~/srcPLgrado/temperature(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/temperature # 27/01/2014
index.html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JavaScript Temperature Converter</title>
<link href=normalize.css" rel="stylesheet" type="text/css">
<link href="global.css" rel="stylesheet" type="text/css">
<script type="text/javascript" src="temperature.js"></script>
</head>
<body>
<h1>Temperature Converter</h1>
<table>
<tr>
<th>Enter Temperature (examples: 32F, 45C, -2.5f):</th>
<td><input id="original" autofocus onchange="calculate();" placeholder="32F" size="50"
</tr>
<tr>
<th>Converted Temperature:</th>
9
<td><span class="output" id="converted"></span></td>
</tr>
</table>
</body>
</html>
Escribir HTML es farragoso. Una soluci´on es usar alg´
un plugin para su editor favorito.
Emmet existe para diversos editores, entre ellos para
En el caso de vim podemos usar Emmet-vim decargandolo desde http://www.vim.org/.
Para Atom: podemos usar Plugin Emmet para Atom en GitHub
• cheat-sheet de Atom
• V´ease el art´ıculo Recommended GitHub Atom Packages for Web Developers.
En cloud9 (c9.io) el plugin ya viene instalado
Documentaci´
on de Emmet
Emmet cheat sheet
The input tag specifies an input field where the user can enter data.
<input> elements are used within a <form> element to declare input controls that allow users
to input data.
An input field can vary in many ways, depending on the type attribute.
The type attribute specifies the type of <input> element to display. The default type is text.
Other values are:
• button
• checkbox
• color
• date
• datetime
• datetime-local
• email
• file
• hidden
• image
• month
• number
• password
• radio
• range
• reset
• search
• submit
• tel
10
• text
• time
• url
• week
The elements used to create controls generally appear inside a <form> element, but may also
appear outside of a <form> element declaration.
The onchange event occurs when the value of an element has been changed.
The <link> tag defines a link between a document and an external resource.
The rel attribute is required. It specifies the relationship between the current document and
the linked document
The <link> tag is used to link to external CSS style sheets.
<link href="global.css" rel="stylesheet" type="text/css">
CSS stands for Cascading Style Sheets and is a separate, but complementary, language to HTML.
CSS is what we use to apply styles to the content on our web page.
global.css
[~/srcPLgrado/temperature(master)]$ cat global.css
th, td
{ vertical-align: top; text-align: right; font-size:large; }
/* Don’t center t
#converted { color: red; font-weight: bold; font-size:large;
}
/* Calculated val
input
{
text-align: right;
/* Align input to the right */
border: none;
border-radius: 20px 20px 20px 20px;
padding: 5px 5px;
font-size:large;
}
body
{
background-color:#b0c4de; /* blue */
font-size:large;
font-family: "Lucida Sans Typewriter", "Lucida Console", Monaco, "Bitstream Vera Sans Mono",
}
h1 {
font-weight: normal;
font-family: "Brush Script MT", cursive;
background: #3C5681;
padding: 5px 15px;
color: white;
display:inline-block;
border-radius: 10px 10px 10px 10px;
}
11
Sint´
axis CSS
th, td
{ vertical-align: top; text-align: right; font-size:large; }
/* Don’t center t
What you see above is referred to as a rule set.
Notice the curly braces. Also, notice that each declaration inside the curly braces has a semicolon.
Everything inside the curly braces is called a declaration block.
The portion prior to the first curly brace is what defines which part of the web page we are
styling. This is referred to as the selector.
Here we’re using commas to separate our selectors th and td. This is a useful method to use to
combine multiple selectors in a single rule set. In this case, the styles will apply to all <th> and
<td> elements,
Each of the three declarations in the declaration block is referred to as a declaration.
Additionally, each declaration consists of a property (the part before the colon) and a value (the
part after the colon).
Each CSS declaration ends with a semicolon.
Selectores en CSS
A selector of nav would match all HTML <nav> elements, and a selector of ul would match all
HTML unordered lists, or <ul> elements.
An ID selector is declared using a hash, or pound symbol (#) preceding a string of characters.
The string of characters is defined by the developer. This selector matches any HTML element
that has an ID attribute with the same value as that of the selector, but minus the hash symbol.
The rule:
#converted
{ color: red; font-weight: bold; font-size:large; } /* Calculated values in bo
applies to:
<span class="output" id="converted">
An ID element on a web page should be unique.
Ejercicio 1.2.1.
Dado el selector
#container .box {
float: left;
padding-bottom: 15px;
}
¿A que elementos de este HTML se aplica?
<div id="container">
<div class="box"></div>
<div class="box-2"></div>
</div>
<div class="box"></div>
12
Dada esta regla
#container > .box {
float: left;
padding-bottom: 15px;
}
¿A que elementos de este HTML se aplica?
<div id="container">
<div class="box"></div>
<div>
<div class="box"></div>
</div>
</div>
Dada esta regla
h2 ~ p { margin-bottom: 20px; }
¿A que elementos de este HTML se aplica?
<h2>Title</h2>
<p>Paragraph example 1.</p>
<p>Paragraph example 2.</p>
<p>Paragraph example 3.</p>
<div class="box">
<p>Paragraph example 4.</p>
</div>
Dada esta regla
p+ p {
text-indent: 1.5em; margin-bottom: 0;
}
¿A que elementos de este HTML se aplica?
<h2>Title</h2>
<p>Paragraph example 1.</p>
<p>Paragraph example 2.</p>
<p>Paragraph example 3.</p>
<div class="box">
<p>Paragraph example 4.</p>
<p>Paragraph example 5.</p>
</div>
Dada esta regla:
input[type="text"] {
background-color: #444;
width: 200px;
}
¿A que elementos de este HTML se aplica?
13
<input type="text">
<input type="submit">
Dada esta regla:
a:hover {
color: red;
}
¿Que porci´
on del selector es conocido como pseudo-clase? ¿Cuando se aplica la regla a un ancla
<a>?
Exprese con palabras a que elementos del documento se aplicar´
a la siguiente regla:
#form [type=text] { border: solid 1px #ccc; }
Ejercicio 1.2.2.
Supuesto que una hoja de estilo contiene estas reglas:
p { font-size: 20px; }
p { font-size: 30px; }
¿Cual ser´
a el tama˜
no de font que se aplique a los elementos p´
arrafo?
Supuesto que una hoja de estilo contiene estas reglas:
div p { color: blue; }
p{ color: red; }
¿Cual ser´
a el color que se aplique a los elementos p´
arrafo?
Supuesto que una hoja de estilo contiene estas reglas:
#main {
color: green;
}
body div.container {
color: pink;
}
¿Cual ser´
a el color que se aplique a este elemento <div>?
<div id="main" class="container"></div>
CSS reset
Every browser applies certain styles to elements on a web page by default.
For example, if you use an un-ordered list (the <ul> element) the browser will display the list with
some existing formatting styles, including bullets next to the individual list items (the <li> elements
inside the <ul>).
By using a CSS reset document at the top of your CSS file, you can reset all these styles to a bare
minimum.
Two of the most popular CSS resets are Eric Meyer’s Reset and Nicolas Gallagher’s Normalize.css
<title>JavaScript Temperature Converter</title>
<link href=normalize.css" rel="stylesheet" type="text/css">
<link href="global.css" rel="stylesheet" type="text/css">
14
El Modelo de Caja
The box model refers to the usually invisible rectangular area that is created for each HTML
element. This area has four basic components
Content
The content portion of the box model holds the actual content.
The content can be text, images, or whatever else is visible on a web page.
Padding
The padding of an element is defined using the padding property. The padding is the space
around the content.
It can be defined for an individual side (for example, padding-left: 20px) or for all four sides
in one declaration padding: 20px 10px 30px 20px, for instance.
When declaring all four sides, you’re using a shorthand property.
Often when a CSS property takes multiple values like this, they start at the top and go clockwise
in relation to the element. So, in the example just cited, this would apply 20px of padding to
the top, 10px to the right, 30px to the bottom, and 20px to the left.
See padding examples at w3schools.
Border
The border of an element is defined using the border property.
This is a shorthand property that defines the element’s border-width, border-style, and
border-color. For example,
border: 4px dashed orange.
Margin
Margins are similar to padding, and are defined using similar syntax
margin-left: 15px
or
margin: 10px 20px 10px 20px
The margin portion of an element exists outside the element.
A margin creates space between the targeted element and surrounding elements.
Ejercicio 1.2.3.
Dadas las declaraciones:
.example {
border-style: dashed;
border-width: 2px;
border-color: blue;
}
.example {
border: solid;
color: green;
}
15
¿De que color queda el borde de los elementos de clase example? ¿Que border-style tendr´
an?
¿Que border-width tendr´
an?
See gist
Dada la declaraci´
on:
.example {
margin: 10px 20px;
}
¿De que tama˜
no quedar´
an margin-top margin-right, margin-bottom y margin-left para los
elementos de clase example?
Editing CSS styles in Chrome using various DevTools aid
While you can not ”debugC
¸ SS, because it is not a scripting language, you can utilize the Chrome
DevTools Elements panel to inspect an element and view the Styles pane on the right.
This will give you insights as to the styles being overridden or ignored (line threw).
The Styles pane is also useful because of it’s ability to LiveEdit the document being inspected,
which may help you iron out the issues.
If the styles are being overridden, you can then view the Computed Style pane to see the CSS that
is actually being utilized to style your document.
Editing styles in Chrome developer pages.
stackoverflow: Debugging CSS in Google Chrome
Chrome DevTools for CSS - Better CSS Coding and CSS Debugging with Developer Tools en YouTube by LearnCode.academy
Block versus Inline
HTML elements fall under two categories: block or inline.
Block-level elements include elements like <div>, <p>, h1, li and <section>. A block-level
element is more of a structural, layout related element.
A block element is an element that takes up the full width available, and has a line break before
and after it.
An inline element only takes up as much width as necessary, and does not force line breaks.
Inline elements behave like words and letters within of a paragraph.
Inline elements include <span>, <b>, and <em>.
It’s worth noting that inline elements are subject to CSS properties that affect text. For example,
line-height and letter-spacing are CSS properties that can be used to style inline elements.
However, those same properties wouldn’t affect block elements.
See
• CSS display Property
• CSS Display - Block and Inline Elements at w3schools
Propiedades CSS
The vertical-align property sets the vertical alignment of an element.
The text-align property specifies the horizontal alignment of text in an element.
The font-family property specifies the font for an element.
The font-family property can hold several font names as a ”fallback”system. If the browser does
not support the first font, it tries the next font.
16
temperature.js
"use strict"; // Use ECMAScript 5 strict mode in browsers that support it
function calculate() {
var result;
var original
= document.getElementById("........");
var temp = original.value;
var regexp = /.............................../;
var m = temp.match(......);
if (m) {
var num = ....;
var type = ....;
num = parseFloat(num);
if (type == ’c’ || type == ’C’) {
result = (num * 9/5)+32;
result = ..............................
}
else {
result = (num - 32)*5/9;
result = ............................
}
converted.innerHTML = result;
}
else {
converted.innerHTML = "ERROR! Try something like ’-4.2C’ instead";
}
}
Despliegue
Deber´a desplegar la aplicaci´on en GitHub Pages como p´agina de proyecto. Vea la secci´
on GitHub
Project Pages 11.4.3.
Creando un fichero package.json
The command:
npm init [-f|--force|-y|--yes]
Will ask you a bunch of questions, and then write a package.json for you.
If you already have a package.json file, it’ll read that first, and default to the options in there.
It is strictly additive, so it does not delete options from your package.json without a really good
reason to do so.
If you invoke it with -f, --force, it will use only defaults and not prompt you for any options.
[/tmp/pl-grado-temperature-converter(karma)]$ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sane defaults.
See ‘npm help json‘ for definitive documentation on these fields
and exactly what they do.
17
Use ‘npm install <pkg> --save‘ afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (pl-grado-temperature-converter)
version: (0.0.0) 0.0.1
description: ULL ESIT Grado de Inform´
atica. 3o . PL. Lab "Temperature Converter"
entry point: (temperature.js)
test command: open tests/index.html
git repository: (ssh:[email protected]/casiano/pl-grado-temperature-converter.git)
keywords: regexp
author: Casiano
license: (ISC)
About to write to /private/tmp/pl-grado-temperature-converter/package.json:
{
"name": "pl-grado-temperature-converter",
"version": "0.0.1",
"description": "ULL ESIT Grado de Inform´
atica. 3o . PL. Lab \"Temperature Converter\"",
"main": "temperature.js",
"directories": {
"test": "tests"
},
"scripts": {
"test": "open tests/index.html"
},
"repository": {
"type": "git",
"url": "ssh:[email protected]/casiano/pl-grado-temperature-converter.git"
},
"keywords": [
"regexp"
],
"author": "Casiano",
"license": "ISC"
}
Is this ok? (yes) y
Esto genera el fichero package.json:
[/tmp/pl-grado-temperature-converter(karma)]$ ls -ltr | tail -1
-rw-r--r-- 1 casiano wheel
487 5 feb 18:22 package.json
Si ahora escribo:
[/tmp/pl-grado-temperature-converter(karma)]$ npm test
> [email protected] test /private/tmp/pl-grado-temperature-converter
> open tests/index.html
Ejecutamos las pruebas en el navegador (en Mac OS X) supuesto que ya estuvieran escritas.
18
Pruebas: Mocha y Chai
Mocha is a test framework while Chai is an expectation one.
Mocha is the simple, flexible, and fun JavaScript unit-testing framework that runs in Node.js or
in the browser.
It is open source (MIT licensed), and we can learn more about it at https://github.com/mochajs/mocha
Let’s say Mocha setups and describes test suites and Chai provides convenient helpers to perform
all kinds of assertions against your JavaScript code.
Pruebas: Estructura
Podemos instalar mocha globalmente:
$ npm install -g mocha
pero podemos tambi´en a˜
nadirlo en package.json como una devDependencies:
[/tmp/pl-grado-temperature-converter(karma)]$ head -n 5 package.json
{
"dependencies": {},
"devDependencies": {
"mocha": "latest"
},
Y ahora podemos instalar todas las dependencias usando npm install:
$ npm install
npm http GET https://registry.npmjs.org/mocha
npm http 200 https://registry.npmjs.org/mocha
npm http GET https://registry.npmjs.org/commander/2.3.0
...
En este caso mocha es instalado localmente, no globalmente:
[/tmp/pl-grado-temperature-converter(karma)]$ ls -ltr node_modules/
total 0
drwxr-xr-x 12 casiano staff 408 5 feb 18:40 mocha
Una vez instalado Mocha, creamos la estructura para las pruebas:
$ mocha init tests
esto en el caso de que lo hayamos instalado globalmente o bien
$ node_modules/mocha/bin/mocha init tests
si lo hemos instalado localmente.
$ tree tests
tests
|-- index.html
|-- mocha.css
|-- mocha.js
‘-- tests.js
A˜
nadimos chai.js (V´ease http://chaijs.com/guide/installation/) al directorio tests.
Chai is a platform-agnostic BDD/TDD assertion library featuring several interfaces (for example,
should, expect, and assert). It is open source (MIT licensed), and we can learn more about it at
http://chaijs.com/
We can also install Chai on the command line using npm, as follows:
19
npm install chai --save-dev
The latest tagged version will be available for hot-linking at http://chaijs.com/chai.js.
If you prefer to host yourself, use the chai.js file from the root of the github project.
[/tmp/pl-grado-temperature-converter(karma)]$ curl https://raw.githubusercontent.com/chaijs/cha
% Total
% Received % Xferd Average Speed
Time
Time
Time Current
Dload Upload
Total
Spent
Left Speed
100 118k 100 118k
0
0 65521
0 0:00:01 0:00:01 --:--:-- 65500
Ya tenemos nuestro fichero tests/chai.js:
[/tmp/pl-grado-temperature-converter(karma)]$ head tests/chai.js
;(function(){
/**
* Require the module at ‘name‘.
*
* @param {String} name
* @return {Object} exports
* @api public
*/
Quedando el ´arbol como sigue:
[~/srcPLgrado/temperature(master)]$ tree tests/
tests/
|-- chai.js
|-- index.html
|-- mocha.css
|-- mocha.js
‘-- tests.js
0 directories, 5 files
Pruebas: index.html
Modificamos el fichero tests/index.html que fu´e generado por mocha init para
Cargar chai.js
Cargar temperature.js
Usar el estilo mocha.setup(’tdd’):
Imitar la p´agina index.html con los correspondientes input y span:
<input id="original" placeholder="32F" size="50">
<span class="output" id="converted"></span>
quedando as´ı:
[~/srcPLgrado/temperature(master)]$ cat tests/index.html
<!DOCTYPE html>
<html>
<head>
<title>Mocha</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
20
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="mocha.css" />
</head>
<body>
<div id="mocha"></div>
<input id="original" placeholder="32F" size="50">
<span class="output" id="converted"></span>
<script src="chai.js"></script>
<script src="mocha.js"></script>
<script src="../temperature.js"></script>
<script>mocha.setup(’tdd’)</script>
<script src="tests.js"></script>
<script>
mocha.run();
</script>
</body>
</html>
Pruebas: A˜
nadir los tests
The ”TDD¨ınterface provides
suite()
test()
setup()
teardown().
[~/srcPLgrado/temperature(master)]$ cat tests/tests.js
var assert = chai.assert;
suite(’temperature’, function() {
test(’32F = 0C’, function() {
original.value = "32F";
calculate();
assert.deepEqual(converted.innerHTML, "0.0 Celsius");
});
test(’45C = 113.0 Farenheit’, function() {
original.value = "45C";
calculate();
assert.deepEqual(converted.innerHTML, "113.0 Farenheit");
});
test(’5X = error’, function() {
original.value = "5X";
calculate();
assert.match(converted.innerHTML, /ERROR/);
});
});
The BDD interface provides describe(), it(), before(), after(), beforeEach(), and afterEach():
describe(’Array’, function(){
21
before(function(){
// ...
});
describe(’#indexOf()’, function(){
it(’should return -1 when not present’, function(){
[1,2,3].indexOf(4).should.equal(-1);
});
});
});
The Chai should style allows for the same chainable assertions as the expect interface, however it
extends each object with a should property to start your chain.
Chai Assert Style
The assert style is exposed through assert interface.
This provides the classic assert-dot notation, similiar to that packaged with node.js.
This assert module, however, provides several additional tests and is browser compatible.
var assert = require(’chai’).assert
, foo = ’bar’
, beverages = { tea: [ ’chai’, ’matcha’, ’oolong’ ] };
assert.typeOf(foo, ’string’, ’foo is a string’);
assert.equal(foo, ’bar’, ’foo equal ‘bar‘’);
assert.lengthOf(foo, 3, ’foo‘s value has a length of 3’);
assert.lengthOf(beverages.tea, 3, ’beverages has 3 types of tea’);
In all cases, the assert style allows you to include an optional message as the last parameter in the
assert statement.
These will be included in the error messages should your assertion not pass.
Assert API, Expect/Should API
Here is the documentation of the Assert API.
Here is the documentation of the Should/Expect API.
Chai Expect Style
The BDD style is exposed through expect or should interfaces. In both scenarios, you chain together
natural language assertions.
var expect = require(’chai’).expect
, foo = ’bar’
, beverages = { tea: [ ’chai’, ’matcha’, ’oolong’ ] };
expect(foo).to.be.a(’string’);
expect(foo).to.equal(’bar’);
expect(foo).to.have.length(3);
expect(beverages).to.have.property(’tea’).with.length(3);
Expect also allows you to include arbitrary messages to prepend to any failed assertions that might
occur.
var answer = 43;
22
// AssertionError: expected 43 to equal 42.
expect(answer).to.equal(42);
// AssertionError: topic [answer]: expected 43 to equal 42.
expect(answer, ’topic [answer]’).to.equal(42);
This comes in handy when being used with non-descript topics such as booleans or numbers.
Ejecuci´
on Simple
tests/index.html:
Ahora podemos ejecutar las pruebas abriendo en el navegador el fichero
$ open tests/index.html
Esta informaci´
on aparece tambi´en en las secciones Unit Testing: Mocha 11.4.1 de estos apuntes.
Manejando tareas en JS: Gulp
Why would you want to use a task runner ?
They’re small applications that automate often time consuming and boring tasks.
If you ever need to do any of the following then a task runner is for you:
Minification and concatenation of JavaScript and CSS files
CSS Preprocessing
Testing
By creating a task file you can instruct the task manager to take care of many development tasks and
watch for changes in relevant files. All you’ll need to do is start up the task runner and get to work
on the more interesting parts of your project.
We are going to use gulp as our task manager. To install it you can:
Install gulp globally:
$ npm install --global gulp
Or you can install gulp in your project devDependencies:
$ npm install --save-dev gulp
This will install gulp in ./node_modules and it will add a line to package.json as the following:
"devDependencies": {
"mocha": "latest",
"gulp": "~3.8.10"
},
Now we can write our gulpfile:
[/tmp/pl-grado-temperature-converter(karma)]$ cat gulpfile.js
var gulp
= require(’gulp’),
gutil
= require(’gulp-util’),
uglify = require(’gulp-uglify’),
concat = require(’gulp-concat’);
var del
= require(’del’);
var minifyHTML = require(’gulp-minify-html’);
var minifyCSS = require(’gulp-minify-css’);
23
gulp.task(’minify’, function () {
gulp.src(’temperature.js’)
.pipe(uglify())
.pipe(gulp.dest(’minified’));
gulp.src(’./index.html’)
.pipe(minifyHTML())
.pipe(gulp.dest(’./minified/’))
gulp.src(’./*.css’)
.pipe(minifyCSS({keepBreaks:true}))
.pipe(gulp.dest(’./minified/’))
});
gulp.task(’clean’, function(cb) {
del([’minified/*’], cb);
});
See gulp API docs
gulp.task(name, fn) – registers a function with a name
gulp.src(glob) – returns a readable stream
The pipe() method takes the source stream derived from the src() method and passes it to
the specific plugin being referenced.
gulp.dest(folder) – returns a writable stream
gulp.watch(glob, fn) – runs a function when a file that matches the glob changes
Gulp on its own doesn’t do a lot. We need to install plugins and add tasks to the gulpfile to put
Gulp into action. To concatenate files we’ll need the gulp-concat plugin; to install it run this from the
command line:npm install gulp-concat --save-dev
the four Gulp methods that we will be using:- Again, if you check your package.json file you should
see a new line referencing the newly installed plugin:"gulp-concat": "~2.1.7"
Despu´es de instalar todas las dependencias:
$ npm i gulp-util --save-dev
$ npm i gulp-... --save-dev
podemos ejecutar las tareas:
$ gulp minify
[22:07:58] Using gulpfile ~/local/src/javascript/PLgrado/temperature/gulpfile.js
[22:07:58] Starting ’minify’...
Que produce el directorio minified:
24
$ ls -l minified/
total 32
-rw-r--r-- 1 casiano
-rw-r--r-- 1 casiano
-rw-r--r-- 1 casiano
-rw-r--r-- 1 casiano
staff
staff
staff
staff
510
594
2021
334
5
5
5
5
feb
feb
feb
feb
21:56
21:56
21:56
21:56
global.css
index.html
normalize.css
temperature.js
normalize.css index.html
staff
934 4 feb 09:11
staff
749 3 feb 10:40
staff 7798 30 ene 22:00
staff
638 3 feb 15:21
global.css
global.css
index.html
normalize.css
temperature.js
que como vemos ha compactado los ficheros:
$ ls -l temperature.js
-rw-r--r-- 1 casiano
-rw-r--r-- 1 casiano
-rw-r--r-- 1 casiano
-rw-r--r-- 1 casiano
Podemos ver la lista de tareas mediante la opci´
on -T:
$ gulp -T
[22:00:40]
[22:00:40]
[22:00:40]
[22:00:40]
Using gulpfile ~/local/src/javascript/PLgrado/temperature/gulpfile.js
Tasks for ~/local/src/javascript/PLgrado/temperature/gulpfile.js
|-- minify
‘-- clean
Podemos borrar las ficheros generados con gulp clean:
$ gulp clean
[22:00:46] Using gulpfile ~/local/src/javascript/PLgrado/temperature/gulpfile.js
[22:00:46] Starting ’clean’...
[22:00:46] Finished ’clean’ after 7.68 ms
$ ls -l minified/
$
gulp has very few flags to know about. All other flags are for tasks to use if needed.
-v or --version will display the global and local gulp versions
--require <module path> will require a module before running the gulpfile. This is useful for
transpilers but also has other applications. You can use multiple --require flags
--gulpfile <gulpfile path> will manually set path of gulpfile. Useful if you have multiple
gulpfiles. This will set the CWD to the gulpfile directory as well
--cwd <dir path> will manually set the CWD. The search for the gulpfile, as well as the
relativity of all requires will be from here
-T or --tasks will display the task dependency tree for the loaded gulpfile
--tasks-simple will display a plaintext list of tasks for the loaded gulpfile
--color will force gulp and gulp plugins to display colors even when no color support is detected
--no-color will force gulp and gulp plugins to not display colors even when color support is
detected
--silent will disable all gulp logging
Tasks can be executed by running gulp <task> <othertask>.
Just running gulp will execute the task you registered called default.
If there is no default task gulp will error.
See CLI.md at gulpjs/gulp.
25
Karma
Karma: Como Funciona
Karma (See Karma installation) is essentially a tool which spawns a web server that executes
source code against test code for each of the browsers connected.
The results for each test against each browser are examined and displayed via the command line
to the developer such that they can see which browsers and tests passed or failed.
A browser can be captured either
• manually, by visiting the URL where the Karma server is listening (typically http://localhost:9876/)
• or automatically by letting Karma know which browsers to start when Karma is run
Karma also watches all the files, specified within the configuration file, and whenever any file
changes, it triggers the test run by sending a signal the testing server to inform all of the captured
browsers to run the test code again.
Each browser then loads the source files inside an IFrame1 , executes the tests and reports the
results back to the server.
The server collects the results from all of the captured browsers and presents them to the
developer.
Karma: Videos
JS.everywhere(Europe) 2012: Testacular, the Spectacular JavaScript Test Runner - Vojta J´ına YouTube
Introduction to Karma Screencast.
Google Test Automation Conference GTAC 2013: Karma - Test Runner for JavaScript Vojta J´ına.
YouTube
Karma: Opciones en L´ınea de Comandos
[~/srcPLgrado/mocha-chai-browser-demo(master)]$ karma --help
Karma - Spectacular Test Runner for JavaScript.
Usage:
/usr/local/bin/karma <command>
Commands:
start [<configFile>] [<options>] Start the server / do single run.
init [<configFile>] Initialize a config file.
run [<options>] [ -- <clientArgs>] Trigger a test run.
completion Shell completion for karma.
Run --help with particular command to see its description and available options.
Options:
--help
--version
Print usage and options.
Print current version.
1
The iframe tag specifies an inline frame. An inline frame is used to embed another document within the current
HTML document
26
Karma: Generando el Fichero de Configuraci´
on
In order to serve us well, Karma needs to
know about our project in order to test it and this is done via a configuration file.
The configuration file can be generated using karma init:
$ karma init my.conf.js
Which testing framework do you want to use ?
Press tab to list possible options. Enter to move to the next question.
> jasmine
Do you want to use Require.js ?
This will add Require.js plugin.
Press tab to list possible options. Enter to move to the next question.
> no
http://requirejs.org/
Do you want to capture a browser automatically ?
Press tab to list possible options. Enter empty string to move to the next question.
> Chrome
What is the location of your source and test files ?
You can use glob patterns, eg. "js/*.js" or "test/**/*Spec.js".
Enter empty string to move to the next question.
>
Should any of the files included by the previous patterns be excluded ?
You can use glob patterns, eg. "**/*.swp".
Enter empty string to move to the next question.
Do you want Karma to watch all the files and run the tests on change ?
Press tab to list possible options.
> yes
Config file generated at "/Users/casiano/local/src/javascript/PLgrado/mocha-tutorial/karma.conf
The configuration file can be written in CoffeeScript as well. In fact, if you execute karma init
with a .coffee filename extension, it will generate a CoffeeScript file.
Of course, you can write the config file by hand or copy paste it from another project ;-)
[~/srcPLgrado/mocha-tutorial]$ cat karma.conf.js
// Karma configuration
// Generated on Mon Jan 20 2014 16:21:22 GMT+0000 (WET)
module.exports = function(config) {
config.set({
// base path, that will be used to resolve files and exclude
basePath: ’’,
// frameworks to use
frameworks: [’jasmine’],
27
// list of files / patterns to load in the browser
files: [
],
// list of files to exclude
exclude: [
],
// test results reporter to use
// possible values: ’dots’, ’progress’, ’junit’, ’growl’, ’coverage’
reporters: [’progress’],
// web server port
port: 9876,
// enable / disable colors in the output (reporters and logs)
colors: true,
// level of logging
// possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LO
logLevel: config.LOG_INFO,
// enable / disable watching file and executing tests whenever any file changes
autoWatch: true,
// Start these browsers, currently available:
// - Chrome
// - ChromeCanary
// - Firefox
// - Opera (has to be installed with ‘npm install karma-opera-launcher‘)
// - Safari (only Mac; has to be installed with ‘npm install karma-safari-launcher‘)
// - PhantomJS
// - IE (only Windows; has to be installed with ‘npm install karma-ie-launcher‘)
browsers: [’Chrome’, ’Firefox’],
// If browser does not capture in given timeout [ms], kill it
captureTimeout: 60000,
// Continuous Integration mode
// if true, it capture browsers, run tests and exit
28
singleRun: false
});
};
Arrancando Karma. Starting Karma
When starting Karma, the configuration file path can be passed in as the first argument. By
default, Karma will look for karma.conf.js in the current directory.
# Start Karma using your configuration
$ karma start my.conf.js
Some configurations, which are already present within the configuration file, can be overridden by
specifying the configuration as a command line argument for when Karma is executed.
karma start karma-conf.js --command-one --command-two
[~/srcPLgrado/mocha-tutorial]$ karma start --help
Karma - Spectacular Test Runner for JavaScript.
START - Start the server / do a single run.
Usage:
/usr/local/bin/karma start [<configFile>] [<options>]
Options:
--port
--auto-watch
--no-auto-watch
--log-level
--colors
--no-colors
--reporters
--browsers
--capture-timeout
--single-run
--no-single-run
--report-slower-than
--help
<integer> Port where the server is running.
Auto watch source files and run on change.
Do not watch source files.
<disable | error | warn | info | debug> Level of logging.
Use colors when reporting and printing logs.
Do not use colors when reporting or printing logs.
List of reporters (available: dots, progress, junit, growl, coverage).
List of browsers to start (eg. --browsers Chrome,ChromeCanary,Firefox).
<integer> Kill browser if does not capture in given time [ms].
Run the test when browsers captured and exit.
Disable single-run.
<integer> Report tests that are slower than given time [ms].
Print usage and options.
Using Karma with Mocha
To use Karma with Mocha we need the karma-mocha adapter.
If we want to pass configuration options directly to mocha you can do this in the following way
// karma.conf.js
module.exports = function(config) {
config.set({
frameworks: [’mocha’],
files: [
’*.js’
],
client: {
mocha: {
ui: ’tdd’
}
29
}
});
};
(By default the ui is bdd).
Here is an example (https://github.com/crguezl/nathanuniversityexercisesPL/blob/master/scheem8/karma.con
[~/srcPLgrado/nathansuniversity/exercises/scheem8(master)]$ cat karma.conf.js
// Karma configuration
// Generated on Tue Jan 21 2014 12:20:45 GMT+0000 (WET)
module.exports = function(config) {
config.set({
// base path, that will be used to resolve files and exclude
basePath: ’’,
// frameworks to use
frameworks: [’mocha’],
// list of files / patterns to load in the browser
files: [
’js/chai.js’,
’js/jquery-1.10.2.js’,
’js/mocha.js’,
’js/scheem8.js’,
’js/simpletest.js’
],
// list of files to exclude
exclude: [
],
// test results reporter to use
// possible values: ’dots’, ’progress’, ’junit’, ’growl’, ’coverage’
reporters: [’progress’],
// web server port
port: 9876,
// enable / disable colors in the output (reporters and logs)
colors: true,
// level of logging
// possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LO
30
logLevel: config.LOG_INFO,
// enable / disable watching file and executing tests whenever any file changes
autoWatch: true,
// Start these browsers, currently available:
// - Chrome
// - ChromeCanary
// - Firefox
// - Opera (has to be installed with ‘npm install karma-opera-launcher‘)
// - Safari (only Mac; has to be installed with ‘npm install karma-safari-launcher‘)
// - PhantomJS
// - IE (only Windows; has to be installed with ‘npm install karma-ie-launcher‘)
browsers: [’Chrome’, ’Firefox’],
// If browser does not capture in given timeout [ms], kill it
captureTimeout: 60000,
// Continuous Integration mode
// if true, it capture browsers, run tests and exit
singleRun: false,
client: {
mocha: {
ui: ’tdd’
}
}
});
};
Load HTML files with Karma
If you have one html file:
[~/srcPLgrado/karma/html]$ cat template.html
<div id="tpl">content of the template</div>
which you want to load and then get all elements from that html page in your test script, you can use
the html2js preprocessor, which basically converts HTML files into JavaScript strings and include
these files.
[~/srcPLgrado/karma/html]$ cat karma.conf.js
module.exports = function(karma) {
karma.configure({
basePath: ’’,
frameworks: [’jasmine’],
files: [ ’*.js’, ’*.html’ ],
preprocessors: { ’*.html’: ’html2js’ },
....
Then, you can access these strings in your test:
31
[~/srcPLgrado/karma/html]$ cat test.js
describe(’template’, function() {
it(’should expose the templates to __html__’, function() {
document.body.innerHTML = __html__[’template.html’];
expect(document.getElementById(’tpl’)).toBeDefined();
})
})
See
Load HTML files with Karma in StackOverflow.
karma-html2js-preprocessor
Example
Pruebas: V´
ease
Mocha, Chai y Sinon
• Testing your frontend JavaScript code using mocha, chai, and sinon by Nicolas Perriault
• Get your Frontend JavaScript Code Covered by Nicolas Perriault
• Github repo crguezl/mocha-chai-sinon–example with Nicolas examples
• Podemos encontrar un ejemplo de unit testing en JavaScript en el browser con el testing framework Mocha y Chai en el repositorio https://github.com/ludovicofischer/mocha-chai-browser-demo:
An example setup for unit testing JavaScript in the browser with the Mocha testing framework and C
• Testing in Browsers and Node with Mocha, Chai, Sinon, and Testem
Gulp
• The Front-end Tooling Book
• An Introduction to Gulp.js by Craig Buckler SitePoint
• Gulp: the modern frontend factory
• Building With Gulp by Callum Macrae
Karma
• Introduction to Karma Screencast.
• Vojta Jina: Testacular (now Karma) - JavaScript test runner. YouTube.
1.3.
Pr´
actica: Comma Separated Values. CSV
Donde
[~/srcPLgrado/csv(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/csv
V´ease https://bitbucket.org/casiano/pl-grado-csv/src y https://github.com/crguezl/csv.
Introducci´
on al formato CSV
V´ease Comma Separated Values en la Wikipedia:
A comma-separated values (CSV) file stores tabular data (numbers and text) in plain-text form. A
CSV file consists of any number of records, separated by line breaks of some kind; each record consists
of fields, separated by a comma. All records have an identical sequence of fields.
32
Ejemplo de ejecuci´
on
V´ease la p´agina en http://crguezl.github.io/csv/. Pruebe a dar como entrada cualquiera de estas
dos
[~/srcPLgrado/csv(gh-pages)]$ cat input.txt
"producto",
"precio"
"camisa",
"4,3"
"libro de O\"Reilly", "7,2"
[~/srcPLgrado/csv(gh-pages)]$ cat input2.txt
"producto",
"precio" "fecha"
"camisa",
"4,3",
"14/01"
"libro de O\"Reilly", "7,2"
"13/02"
Pruebe tambi´en a dar alguna entrada err´onea.
Figura 1.1: Ejemplo de pantalla de La aplicaci´on para el An´
alisis de Datos en Formato CSV
Aproximaci´
on al an´
alisis mediante expresiones regulares de CSV
ci´
on ser´ıa hacer split por las comas:
Una primera aproxima-
> x = ’"earth",1,"moon",9.374’
’"earth",1,"moon",9.374’
> y = x.split(/,/)
[ ’"earth"’, ’1’, ’"moon"’, ’9.374’ ]
Esta soluci´on deja las comillas dobles en los campos entrecomillados. Peor a´
un, los campos entrecomillados pueden contener comas, en cuyo caso la divisi´
on proporcionada por split ser´ıa err´onea:
> x = ’"earth, mars",1,"moon, fobos",9.374’
’"earth, mars",1,"moon, fobos",9.374’
> y = x.split(/,/)
[ ’"earth’, ’ mars"’, ’1’, ’"moon’, ’ fobos"’, ’9.374’ ]
33
La siguiente expresi´
on regular reconoce cadenas de comillas dobles con secuencias de escape seguidas opcionalmente de una coma:
> x = ’"earth, mars",1,"moon, fobos",9.374’
’"earth, mars",1,"moon, fobos",9.374’
> r = /"((?:[^"\\]|\\.)*)"\s*,?/g
/"((?:[^"\\]|\\.)*)"\s*,?/g
> w = x.match(r)
[ ’"earth, mars",’, ’"moon, fobos",’ ]
If your regular expression uses the g flag, you can use the exec or match methods multiple times to
find successive matches in the same string. When you do so, the search starts at the substring of string
specified by the regular expression’s lastIndex property.
Javascript sub-matches stop working when the g modifier is set:
> text = ’test test test test’
’test test test test’
> text.match(/t(e)(s)t/)
[ ’test’, ’e’, ’s’, index: 0, input: ’test test test test’ ]
> text.match(/t(e)(s)t/g)
[ ’test’, ’test’, ’test’, ’test’ ]
Sin embargo el m´etodo exec de las expresiones regulares si que conserva las subexpresiones que casan
con los par´entesis:
> r = /t(e)(s)t/g
/t(e)(s)t/g
> text = ’test test test test’
’test test test test’
> while (m = r.exec(text)) {
... console.log(m);
... }
[ ’test’, ’e’, ’s’, index: 0, input: ’test test test test’ ]
[ ’test’, ’e’, ’s’, index: 5, input: ’test test test test’ ]
[ ’test’, ’e’, ’s’, index: 10, input: ’test test test test’ ]
[ ’test’, ’e’, ’s’, index: 15, input: ’test test test test’ ]
undefined
Another catch to remember is that exec() doesn’t return the matches in one big array: it keeps
returning matches until it runs out, in which case it returns null.
V´ease
Javascript Regex and Submatches en StackOverflow.
La secci´
on Ejercicios 1.5
Esta otra expresi´
on regular /([^,]+),?|\s*,/ act´
ua de forma parecida al split. Reconoce secuencias no vac´ıas de caracteres que no contienen comas seguidas opcionalmente de una coma o bien
una s´
ola coma (precedida opcionalmente de blancos):
> x = ’"earth, mars",1,"moon, fobos",9.374’
’"earth, mars",1,"moon, fobos",9.374’
> r = /([^,]+),?|\s*,/g
/([^,]+),?|\s*,/g
> w = x.match(r)
[ ’"earth,’, ’ mars",’, ’1,’, ’"moon,’, ’ fobos",’, ’9.374’ ]
La siguiente expresi´
on regular es la uni´
on de dos:
34
Cadenas de dobles comillas seguidas de una coma opcional entre espacios en blanco
Cadenas que no tienen comas
> x = ’"earth, mars",1,"moon, fobos",9.374’
’"earth, mars",1,"moon, fobos",9.374’
> r = /\s*"((?:[^"\\]|\\.)*)"\s*,?|\s*([^,]+),?|\s*,/g
/\s*"((?:[^"\\]|\\.)*)"\s*,?|\s*([^,]+),?|\s*,/g
> w = x.match(r)
[ ’"earth, mars",’, ’1,’, ’"moon, fobos",’, ’9.374’ ]
El operador | trabaja en circuito corto:
> r = /(ba?)|(b)/
/(ba?)|(b)/
> r.exec("ba")
[ ’ba’, ’ba’, undefined, index: 0, input: ’ba’ ]
> r = /(b)|(ba?)/
/(b)|(ba?)/
> r.exec("ba")
[ ’b’, ’b’, undefined, index: 0, input: ’ba’ ]
Si usamos exec tenemos:
> x = ’"earth, mars",1,"moon, fobos",9.374’
’"earth, mars",1,"moon, fobos",9.374’
> r = /\s*"((?:[^"\\]|\\.)*)"\s*,?|\s*([^,]+),?|\s*,/g
/\s*"((?:[^"\\]|\\.)*)"\s*,?|\s*([^,]+),?|\s*,/g
> while (m = r.exec(x)) { console.log(m); }
[ ’"earth, mars",’, ’earth, mars’, undefined, index: 0,
input: ’"earth, mars",1,"moon, fobos",9.374’ ]
[ ’1,’, undefined, ’1’, index: 14,
input: ’"earth, mars",1,"moon, fobos",9.374’ ]
[ ’"moon, fobos",’, ’moon, fobos’, undefined, index: 16,
input: ’"earth, mars",1,"moon, fobos",9.374’ ]
[ ’9.374’, undefined, ’9.374’, index: 30,
input: ’"earth, mars",1,"moon, fobos",9.374’ ]
undefined
1. RegExp Objects
The RegExp constructor creates a regular expression object for matching text with a pattern.
Literal and constructor notations are possible:
/pattern/flags;
new RegExp(pattern [, flags]);
The literal notation provides compilation of the regular expression when the expression is
evaluated.
Use literal notation when the regular expression will remain constant.
For example, if you use literal notation to construct a regular expression used in a loop,
the regular expression won’t be recompiled on each iteration.
The constructor of the regular expression object, for example, new RegExp("ab+c"), provides runtime compilation of the regular expression.
35
Use the constructor function when you know the regular expression pattern will be changing,
or you don’t know the pattern and are getting it from another source, such as user input.
When using the constructor function, the normal string escape rules (preceding special
characters with \ when included in a string) are necessary. For example, the following are
equivalent:
var re = /\w+/;
var re = new RegExp("\\w+");
2. exec
3. search
str.search(regexp)
If successful, search returns the index of the regular expression inside the string. Otherwise, it
returns -1.
When you want to know whether a pattern is found in a string use search (similar to the regular
expression test method); for more information (but slower execution) use match (similar to the
regular expression exec method).
4. match
5. replace
The replace() method returns a new string with some or all matches of a pattern replaced by
a replacement. The pattern can be a string or a RegExp, and the replacement can be a string or
a function to be called for each match.
> re = /apples/gi
/apples/gi
> str = "Apples are round, and apples are juicy."
’Apples are round, and apples are juicy.’
> newstr = str.replace(re, "oranges")
’oranges are round, and oranges are juicy.’
The replacement string can be a function to be invoked to create the new substring (to put in
place of the substring received from parameter #1). The arguments supplied to this function are:
Possible name
match
p1, p2, ...
offset
string
Supplied value
The matched substring. (Corresponds to $&.)
The nth parenthesized submatch string, provided the first argument to rep
(Corresponds to $1, $2, etc.) For example, if /(\a+)(\b+)/, was given, p
p2 for \b+.
The offset of the matched substring within the total string being examined
string was abcd, and the matched substring was bc, then this argument w
The total string being examined
[~/javascript/learning]$ pwd -P
/Users/casiano/local/src/javascript/learning
[~/javascript/learning]$ cat f2c.js
#!/usr/bin/env node
function f2c(x)
{
function convert(str, p1, offset, s)
{
return ((p1-32) * 5/9) + "C";
36
}
var s = String(x);
var test = /(\d+(?:\.\d*)?)F\b/g;
return s.replace(test, convert);
}
var arg = process.argv[2] || "32F";
console.log(f2c(arg));
[~/javascript/learning]$ ./f2c.js 100F
37.77777777777778C
[~/javascript/learning]$ ./f2c.js
0C
index.html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>CSV Analyzer</title>
<link href="global.css" rel="stylesheet" type="text/css">
<script type="text/javascript" src="../../underscore/underscore.js"></script>
<script type="text/javascript" src="../../jquery/starterkit/jquery.js"></script>
<script type="text/javascript" src="csv.js"></script>
</head>
<body>
<h1>Comma Separated Value Analyzer</h1>
<div>
<i>Write a CSV string. Click the table button. The program outputs a table with the spec
</div>
<table>
<tr>
<th>CSV string:</th> <!-- autofocus attribute is HTML5 -->
<td><textarea autofocus cols = "80" rows = "5" id="original"></textarea></td>
</tr>
</table>
<button type="button">table:</button><br>
<span class="output" id="finaltable"></span>
</body>
</html>
jQuery
jQuery (Descarga la librer´ıa)
jQuery is a cross-platform JavaScript library designed to simplify the client-side scripting of HTML.
It was released in January 2006 at BarCamp NYC by John Resig.
It is currently developed by a team of developers led by Dave Methvin.
jQuery is the most popular JavaScript library in use today
jQuery’s syntax is designed to make it easier to navigate a document, select DOM elements,
create animations, handle events, and develop Ajax applications.
37
The set of jQuery core features — DOM element selections, traversal and manipulation —
enabled by its selector engine (named ”Sizzle”from v1.3), created a new ”programming style”,
fusing algorithms and DOM-data-structures; and influenced the architecture of other JavaScript
frameworks like YUI v3 and Dojo.
How JQuery Works
V´ease How jQuery Works
https://github.com/crguezl/how-jquery-works-tutorial en GitHub
[~/javascript/jquery(master)]$ pwd -P
/Users/casiano/local/src/javascript/jquery
~/javascript/jquery(master)]$ cat index.html
<!doctype html>
<html>
<head>
<meta charset="utf-8" />
<title>Demo</title>
</head>
<body>
<a href="http://jquery.com/">jQuery</a>
<script src="starterkit/jquery.js"></script>
<script>
// Your code goes here.
</script>
</body>
</html>
To ensure that their code runs after the browser finishes loading the document, many JavaScript
programmers wrap their code in an onload function:
window.onload = function() { alert( "welcome" ); }
Unfortunately, the code doesn’t run until all images are finished downloading, including banner
ads. To run code as soon as the document is ready to be manipulated, jQuery has a statement known
as the ready event:
$( document ).ready(function() {
// Your code here.
});
For click and most other events, you can prevent the default behavior by calling event.preventDefault()
in the event handler. If this method is called, the default action of the event will not be triggered. For
example, clicked anchors will not take the browser to a new URL.
[~/javascript/jquery(master)]$ cat index2.html
<!doctype html>
<html>
<head>
38
<meta charset="utf-8" />
<title>Demo</title>
</head>
<body>
<a href="http://jquery.com/">jQuery</a>
<script src="starterkit/jquery.js"></script>
<script>
$( document ).ready(function() {
$( "a" ).click(function( event ) {
alert( "The link will no longer take you to jquery.com" );
event.preventDefault();
});
});
</script>
</body>
</html>
Borrowing from CSS 1–3, and then adding its own, jQuery offers a powerful set of tools for matching
a set of elements in a document.
See jQuery Category: Selectors.
Another common task is adding or removing a class. jQuery also provides some handy effects.
[~/javascript/jquery(master)]$ cat index3.html
<!doctype html>
<html>
<head>
<meta charset="utf-8" />
<style>
a.test { font-weight: bold; }
</style>
<title>Demo</title>
</head>
<body>
<a href="http://jquery.com/">jQuery</a>
<script src="starterkit/jquery.js"></script>
<script>
$( document ).ready(function() {
$( "a" ).click(function( event ) {
$( "a" ).addClass( "test" );
alert( "The link will no longer take you to jquery.com" );
event.preventDefault();
$( "a" ).removeClass( "test" );
$( this ).hide( "slow" );
$( this ).show( "slow" );
});
});
</script>
</body>
</html>
39
In JavaScript this always refers to the owner of the function we’re executing, or rather, to the
object that a function is a method of.
When we define our function tutu() in a page, its owner is the page, or rather, the window
object (or global object) of JavaScript.
An onclick property, though, is owned by the HTML element it belongs to.
The method .addClass( className ) adds the specified class(es) to each of the set of matched
elements.
className is a String containing one or more space-separated classes to be added to the class
attribute of each matched element.
This method does not replace a class. It simply adds the class, appending it to any which may
already be assigned to the elements.
The method .removeClass( [className ] ) removes a single class, multiple classes, or all
classes from each element in the set of matched elements.
If a class name is included as a parameter, then only that class will be removed from the set of
matched elements. If no class names are specified in the parameter, all classes will be removed.
This method is often used with .addClass() to switch elements’ classes from one to another,
like so:
$( "p" ).removeClass( "myClass noClass" ).addClass( "yourClass" );
JavaScript enables you to freely pass functions around to be executed at a later time. A callback is
a function that is passed as an argument to another function and is usually executed after its parent
function has completed.
Callbacks are special because they wait to execute until their parent finishes or some event occurs.
Meanwhile, the browser can be executing other functions or doing all sorts of other work.
[~/javascript/jquery(master)]$ cat app.rb
require ’sinatra’
set :public_folder, File.dirname(__FILE__) + ’/starterkit’
get ’/’ do
erb :index
end
get ’/chuchu’ do
if request.xhr?
"hello world!"
else
erb :tutu
end
end
__END__
@@layout
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
40
<title>Demo</title>
</head>
<body>
<a href="http://jquery.com/">jQuery</a>
<div class="result"></div>
<script src="jquery.js"></script>
<%= yield %>
</body>
</html>
@@index
<script>
$( document ).ready(function() {
$( "a" ).click(function( event ) {
event.preventDefault();
$.get( "/chuchu", function( data ) {
$( ".result" ).html( data );
alert( "Load was performed." );
});
});
});
</script>
@@tutu
<h1>Not an Ajax Request!</h1>
jQuery.get( url [, data ] [, success(data, textStatus, jqXHR) ] [, dataType ] ) load
data from the server using a HTTP GET request.
url
Type: String
A string containing the URL to which the request is sent.
data
Type: PlainObject or String
A plain object or string that is sent to the server with the request.
success(data, textStatus, jqXHR)
Type: Function()
A callback function that is executed if the request succeeds.
dataType
Type: String
The type of data expected from the server. Default: Intelligent Guess (xml, json, script, or
html).
To use callbacks, it is important to know how to pass them into their parent function.
Executing callbacks with arguments can be tricky.
This code example will not work:
$.get( "myhtmlpage.html", myCallBack( param1, param2 ) );
The reason this fails is that the code executes
41
myCallBack( param1, param2)
immediately and then passes myCallBack()’s return value as the second parameter to $.get().
We actually want to pass the function myCallBack, not myCallBack( param1, param2 )’s return
value (which might or might not be a function).
So, how to pass in myCallBack() and include arguments?
To defer executing myCallBack() with its parameters, you can use an anonymous function as a
wrapper.
[~/javascript/jquery(master)]$ cat app2.rb
require ’sinatra’
set :public_folder, File.dirname(__FILE__) + ’/starterkit’
get ’/’ do
erb :index
end
get ’/chuchu’ do
if request.xhr? # is an ajax request
"hello world!"
else
erb :tutu
end
end
__END__
@@layout
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Demo</title>
</head>
<body>
<a href="http://jquery.com/">jQuery</a>
<div class="result"></div>
<script src="jquery.js"></script>
<%= yield %>
</body>
</html>
@@tutu
<h1>Not an Ajax Request!</h1>
@@index
<script>
var param = "chuchu param";
var handler = function( data, textStatus, jqXHR, param ) {
$( ".result" ).html( data );
alert( "Load was performed.\n"+
"$data = "+data+
"\ntextStatus = "+textStatus+
42
"\njqXHR = "+JSON.stringify(jqXHR)+
"\nparam = "+param );
};
$( document ).ready(function() {
$( "a" ).click(function( event ) {
event.preventDefault();
$.get( "/chuchu", function(data, textStatus, jqXHR ) {
handler( data, textStatus, jqXHR, param);
});
});
});
</script>
El ejemplo en app2.rb puede verse desplegado en Heroku: http://jquery-tutorial.herokuapp.com/
JSON.stringify()
The JSON.stringify() method converts a value to JSON , optionally replacing
values if a replacer function is specified, or optionally including only the specified properties if a
replacer array is specified.
JSON.stringify(value[, replacer [, space]])
value
The value to convert to a JSON string.
replacer
• If a function, transforms values and properties encountered while stringifying;
• if an array, specifies the set of properties included in objects in the final string.
space
Causes the resulting string to be pretty-printed.
See another example of use in http://jsfiddle.net/casiano/j7tsF/. To learn to use JSFiddle wath
the YouTube video How to use JSFiddle by Jason Diamond
Underscore
Underscore: is a utility-belt library for JavaScript that provides a lot of the functional programming
support that you would expect in Ruby.
Underscore provides functions that support methods like:
map, select, invoke
as well as more specialized helpers:
function binding, javascript templating, deep equality testing, and so on.
Cargando la librer´ıa:
[~/javascript/jquery(master)]$ node
> 2+3
5
> _
5
> uu = require(’underscore’)
{ [Function]
_: [Circular],
43
VERSION: ’1.5.2’,
forEach: [Function],
each: [Function],
collect: [Function],
map: [Function],
inject: [Function],
reduce: [Function],
.................
chain: [Function] }
each:
> uu.each([1, 2, 3], function(x) { console.log(x*x); })
1
4
9
map:
> uu.map([1, 2, 3], function(num){ return num * 3; })
[ 3, 6, 9 ]
invoke
>
[
>
[
>
[
z = [[6,9,1],[7,3,9]]
[ 6, 9, 1 ], [ 7, 3, 9 ] ]
uu.invoke(z, ’sort’)
[ 1, 6, 9 ], [ 3, 7, 9 ] ]
uu.invoke(z, ’sort’, function(a, b) { return b-a; })
[ 9, 6, 1 ], [ 9, 7, 3 ] ]
reduce:
> uu.reduce([1,
10
> uu.reduce([1,
24
> uu.reduce([1,
4
> uu.reduce([1,
1
2, 3, 4], function(s, num){ return s + num; }, 0)
2, 3, 4], function(s, num){ return s * num; }, 1)
2, 3, 4], function(s, num){ return Math.max(s, num); }, -1)
2, 3, 4], function(s, num){ return Math.min(s, num); }, 99)
filter: (select is an alias for filter)
> uu.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; })
[ 2, 4, 6 ]
isEqual
> a = {a:[1,2,3], b: { c: 1, d: [5,6]}}
{ a: [ 1, 2, 3 ],
b: { c: 1, d: [ 5, 6 ] } }
> b = {a:[1,2,3], b: { c: 1, d: [5,6]}}
{ a: [ 1, 2, 3 ],
44
b: { c: 1, d: [ 5, 6 ] } }
> a == b
false
> uu.isEqual(a,b)
true
bind
> func = function(greeting){ return greeting + ’: ’ + this.name }
[Function]
> func = uu.bind(func, {name: ’moe’})
[Function]
> func(’hello’)
’hello: moe’
> func = uu.bind(func, {name: ’moe’}, ’hi’)
[Function]
> func()
’hi: moe’
>
Templates en Underscore
Underscore: template
_.template(templateString, [data], [settings])
Compiles JavaScript templates into functions that can be evaluated for rendering. Useful for
rendering complicated bits of HTML from a JavaScript object or from JSON data sources.
JSON, or JavaScript Object Notation, is an open standard format that uses human-readable text
to transmit data objects consisting of attribute–value pairs. It is used primarily to transmit data
between a server and web application, as an alternative to XML. Although originally derived
from the JavaScript scripting language, JSON is a language-independent data format, and code
for parsing and generating JSON data is readily available in a large variety of programming
languages.
• Template functions can both interpolate variables, using <%= ... %>,
> compiled = uu.template("hello: <%= name %>")
{ [Function]
source: ’function(obj){
var __t,__p=\’\’, __j=Array.prototype.join, i
print=function(){__p+=__j.call(arguments,\’\’);};
with(obj||{}){
__p+=\’hello: \’+ ((__t=( name ))==null?\’\’:__t)+ \’\’;
}
return __p;
}’
}
> compiled({name: ’moe’})
’hello: moe’
• as well as execute arbitrary JavaScript code, with <% ... %>.
> uu = require(’underscore’)
> list = "\
... <% _.each(people, function(name) { %>\
45
..... <li><%= name %></li>\
... <% }); %>"
’<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>’
> uu.template(list, {people: [’moe’, ’curly’, ’larry’]})
’ <li>moe</li> <li>curly</li> <li>larry</li> ’
• When you evaluate a template function, pass in a data object that has properties corresponding to the template’s free variables.
If you’re writing a one-off, like in the example above, you can pass the data object as
the second parameter to template in order to render immediately instead of returning a
template function.
• If you wish to interpolate a value, and have it be HTML-escaped, use <%- ... %>
> template = uu.template("<b><%- value %></b>")
{ [Function]
source: ’function(obj){
var __t,__p=\’\’,__j=Array.prototype.join,print=function(){__p+=__j.call(arguments
with(obj||{}){
__p+=\’<b>\’+
((__t=( value ))==null?\’\’:_.escape(__t))+
\’</b>\’;
}
return __p;
}’
}
> template({value: ’<script>’})
’<b>&lt;script&gt;</b>’
• The settings argument should be a hash containing any _.templateSettings that should
be overridden.
_.template("Using ’with’: <%= data.answer %>", {answer: ’no’}, {variable: ’data’});
=> "Using ’with’: no"
Another example:
template = uu.template("<b>{{ value }}</b>",{value: 4 },
{ interpolate: /\{\{(.+?)\}\}/g })
’<b>4</b>’
You can also use print from within JavaScript code. This is sometimes more convenient than
using <%= ... %>.
> compiled = uu.template("<% print(’Hello ’ + epithet); %>")
{ [Function]
source: ’function(obj){\n
var __t,__p=\’\’,
__j=Array.prototype.join,print=function(){
__p+=__j.call(arguments,\’\’);};\n
with(obj||{}){\n
__p+=\’\’;\n print(\’Hello \’ + epithet); \n
__p+=\’\’;\n}\n
return __p;\n
}’
}
> compiled({ epithet : ’stooge’ })
46
’Hello stooge’
>
If ERB-style delimiters aren’t your cup of tea, you can change Underscore’s template settings
to use different symbols to set off interpolated code:
• Define an interpolate regex to match expressions that should be interpolated verbatim,
• an escape regex to match expressions that should be inserted after being HTML escaped,
and
• an evaluate regex to match expressions that should be evaluated without insertion into
the resulting string.
• You may define or omit any combination of the three.
• For example, to perform Mustache.js style templating:
_.templateSettings = {
interpolate: /\{\{(.+?)\}\}/g
};
var template = _.template("Hello {{ name }}!");
template({name: "Mustache"});
=> "Hello Mustache!"
• escape:
> uu.templateSettings.escape = /\{\{-(.*?)\}\}/g
/\{\{-(.*?)\}\}/g
> compiled = uu.template("Escaped: {{- value }}\nNot escaped: {{ value }}")
{ [Function]
source: ’function(obj){\nvar __t,__p=\’\’,__j=Array.prototype.join,print=function(){
> compiled({value: ’Hello, <b>world!</b>’})
’Escaped: Hello, &lt;b&gt;world!&lt;/b&gt;\nNot escaped: {{ value }}’
• Another example:
> uu.templateSettings = {
.....
interpolate: /\<\@\=(.+?)\@\>/gim,
.....
evaluate: /\<\@(.+?)\@\>/gim
.....
}
{ interpolate: /\<\@\=(.+?)\@\>/gim,
evaluate: /\<\@(.+?)\@\>/gim }
> s = " <@ _.each([0,1,2,3,4], function(i) { @> <p><@= i @></p> <@ }); @>"
’ <@ _.each([0,1,2,3,4], function(i) { @> <p><@= i @></p> <@ }); @>’
> uu.template(s,{})
’
<p>0</p>
<p>1</p>
<p>2</p>
<p>3</p>
<p>4</p> ’
By default, template places the values from your data in the local scope via the with statement.
The with statement adds the given object to the head of this scope chain during the evaluation
of its statement body:
> with (Math) {
... s = PI*2;
... }
6.283185307179586
> z = { x : 1, y : 2 }
{ x: 1, y: 2 }
47
> with (z) {
... console.log(y);
... }
2
undefined
However, you can specify a single variable name with the variable setting. This improves the
speed at which a template is able to render.
_.template("Using ’with’: <%= data.answer %>", {answer: ’no’}, {variable: ’data’});
=> "Using ’with’: no"
JSFIDDLE: underscore templates
Stackoverflow::how to use Underscore template
Content delivery network or content distribution network (CDN)
Una CDN que provee underscore esta en http://cdnjs.com/:
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.5.2/
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
A content delivery network or content distribution network (CDN) is a large distributed system of
servers deployed in multiple data centers across the Internet. The goal of a CDN is to serve content
to end-users with high availability and high performance. CDNs serve a large fraction of the Internet
content today, including
web objects (text, graphics and scripts),
downloadable objects (media files, software, documents), applications (e-commerce, portals),
live streaming media, on-demand streaming media, and social networks.
Google provee tambi´en un servicio CDN para los desarrolladores en https://developers.google.com/speed/librar
textarea, autofocus y button
1. textarea:
The <textarea> tag defines a multi-line text input control.
A text area can hold an unlimited number of characters, and the text renders in a fixed-width
font (usually Courier).
The size of a text area can be specified by the cols and rows attributes, or through CSS’ height
and width properties.
cols and rows consider the font size. height and width aren’t.
2. autofocus.
The autofocus attribute is a boolean attribute.
When present, it specifies that the text area should automatically get focus when the page loads.
V´ease tambi´en [1]
3. button:
The <button> tag defines a clickable button.
Inside a <button> element you can put content, like text or images.
48
Local Storage (HTML5 Web Storage)
Web storage and DOM storage (document object model) are web application software methods
and protocols used for storing data in a web browser.
Web storage supports persistent data storage, similar to cookies but with a greatly enhanced
capacity and no information stored in the HTTP request header.
Local Storage nos permite almacenar hasta 5MB del lado del cliente por dominio, esto nos
permite ahora hacer aplicaciones mas robustas y con mas posibilidades. Las Cookies ofrecen
algo parecido, pero con el limite de 100kb.
There are two main web storage types: local storage and session storage, behaving similarly to
persistent cookies and session cookies respectively.
Unlike cookies, which can be accessed by both the server and client side, web storage falls
exclusively under the purview of client-side scripting
The HTML5 localStorage object is isolated per domain (the same segregation rules as the
same origin policy).
The same-origin policy permits scripts running on pages originating from the same site – a
combination of scheme, hostname, and port number – to access each other’s DOM with no
specific restrictions, but prevents access to DOM on different sites.
V´ease:
Ejemplo en GitHub: https://github.com/crguezl/web-storage-example
[~/javascript/local_storage(master)]$ pwd -P
/Users/casiano/local/src/javascript/local_storage
Como usar localstorage
HTML5 Web Storage
W3C Web Storage
Using HTML5 localStorage To Store JSON Options for persistent storage of complex JavaScript
objects in HTML5 by Dan Cruickshank
HTML5 Cookbook. Christopher Schmitt, Kyle Simpson .O’Reilly Media, Inc.”, Nov 7, 2011 Chapter 10. Section 2: LocalStorage
While Chrome does not provide a UI for clearing localStorage, there is an API that will either
clear a specific key or the entire localStorage object on a website.
//Clears the value of MyKey
window.localStorage.clear("MyKey");
//Clears all the local storage data
window.localStorage.clear();
Once done, localStorage will be cleared. Note that this affects all web pages on a single domain, so
if you clear localStorage for jsfiddle.net/index.html (assuming that’s the page you’re on), then it
clears it for all other pages on that site.
49
global.css
html *
{
font-size: large;
/* The !important ensures that nothing can override what you’ve set in this style (unless i
font-family: Arial;
}
h1
{ text-align: center; font-size: x-large; }
th, td
{ vertical-align: top; text-align: right; }
/* #finaltable * { color: white; background-color: black; }
/* #finaltable table { border-collapse:collapse; } */
/* #finaltable table, td { border:1px solid white; } */
#finaltable:hover td { background-color: blue; }
tr:nth-child(odd)
{ background-color:#eee; }
tr:nth-child(even)
{ background-color:#00FF66; }
input
{ text-align: right; border: none;
}
textarea
{ border: outset; border-color: white;
table
{ border: inset; border-color: white; }
table.center { margin-left:auto; margin-right:auto; }
#result
{ border-color: red; }
tr.error
{ background-color: red; }
body
{
background-color:#b0c4de; /* blue */
}
*/
/* Align input to the right
}
1. Introducci´
on a las pseudo clases de CSS3
Una pseudo clase es un estado o uso predefinido de un elemento al que se le puede aplicar un
estilo independientemente de su estado por defecto. Existen cuatro tipos diferentes de pseudo
clases:
Links: Estas pseudo clases se usan para dar estilo al enlace tanto en su estado normal por
defecto como cuando ya ha sido visitado, mientras mantenemos el cursor encima de ´el o
cuando hacemos click en ´el
Dinamicas: Estas pseudo clases pueden ser aplicadas a cualquier elemento para definir como
se muestran cuando el cursor est´a situado sobre ellos, o haciendo click en ellos o bien cuando
son seleccionados
Estructurales: Permiten dar estilo a elementos bas´
andonos en una posici´on num´erica exacta
del elemento
Otras: Algunos elementos pueden ser estilizados de manera diferente bas´
andonos en el
lenguaje o que tipo de etiqueta no son
2. CSS pattern matching
In CSS, pattern matching rules determine which style rules apply to elements in the document
tree. These patterns, called selectors, may range from simple element names to rich contextual
patterns. If all conditions in the pattern are true for a certain element, the selector matches the
element.
The universal selector, written *, matches the name of any element type. It matches any single
element in the document tree.
For example, this rule set will be applied to every element in a document:
50
*/
* {
margin: 0;
padding: 0;
}
3. CSS class selectors
Working with HTML, authors may use the period (.) notation as an alternative to the ~= notation when representing the class attribute. Thus, for HTML, div.value and div[class~=value]
have the same meaning. The attribute value must immediately follow the period (.).
4. CSS3: nth-child() selector The :nth-child(n) selector matches every element that is the nth
child, regardless of type, of its parent.
n can be a number, a keyword, or a formula.
5. The CSS border properties allow you to specify the style and color of an element’s border. The
border-style property specifies what kind of border to display. For example, inset: Defines a 3D
inset border while :outset defines a 3D outset border. The effect depends on the border-color
value
See CSS: border
6.
csv.js
// See http://en.wikipedia.org/wiki/Comma-separated_values
"use strict"; // Use ECMAScript 5 strict mode in browsers that support it
$(document).ready(function() {
$("button").click(function() {
calculate();
});
});
function calculate() {
var result;
var original
= document.getElementById("original");
var temp = original.value;
var regexp = /_____________________________________________/g;
var lines = temp.split(/\n+\s*/);
var commonLength = NaN;
var r = [];
// Template using underscore
var row = "<%% _.each(items, function(name) { %>"
+
"
<td><%%= name %></td>" +
"
<%% }); %>";
if (window.localStorage) localStorage.original
for(var t in lines) {
var temp = lines[t];
var m = temp.match(regexp);
var result = [];
var error = false;
51
= temp;
if (m) {
if (commonLength && (commonLength != m.length)) {
//alert(’ERROR! row <’+temp+’> has ’+m.length+’ items!’);
error = true;
}
else {
commonLength = m.length;
error = false;
}
for(var i in m) {
var removecomma = m[i].replace(/,\s*$/,’’);
var remove1stquote = removecomma.replace(/^\s*"/,’’);
var removelastquote = remove1stquote.replace(/"\s*$/,’’);
var removeescapedquotes = removelastquote.replace(/\"/,’"’);
result.push(removeescapedquotes);
}
var tr = error? ’<tr class="error">’ : ’<tr>’;
r.push(tr+_.template(row, {items : result})+"</tr>");
}
else {
alert(’ERROR! row ’+temp+’ does not look as legal CSV’);
error = true;
}
}
r.unshift(’<p>\n<table class="center" id="result">’);
r.push(’</table>’);
//alert(r.join(’\n’)); // debug
finaltable.innerHTML = r.join(’\n’);
}
window.onload = function() {
// If the browser supports localStorage and we have some stored data
if (window.localStorage && localStorage.original) {
document.getElementById("original").value = localStorage.original;
}
};
1. Tutorials:Getting Started with jQuery
Tareas
A˜
nada pruebas usando Mocha y Chai
1.4.
Comentarios y Consejos
How can I push a local Git branch to a remote with a different name easily?
$ git branch -a
* gh-pages
remotes/origin/HEAD -> origin/gh-pages
remotes/origin/gh-pages
52
Of course a solution for this way to work is to rename your master branch:
$ git branch -m master gh-pages
[~/Downloads/tmp(gh-pages)]$ git branch
* gh-pages
Otherwise, you can do your initial push this way:
$ git push -u origin master:gh-pages
Option -u: for every branch that is up to date or successfully pushed, add upstream (tracking) reference, used by argument-less git-pull.
How can I push a local Git branch to a remote with a different name easily?
favicons y shortcut icons
A favicon (short for Favorite icon), also known as a shortcut icon, is a file containing one or
more small icons, most commonly 16×16 pixels, associated with a particular Web site or Web
page.
A web designer can create such an icon and install it into a Web site (or Web page) by several
means, and graphical web browsers will then make use of it.
Browsers that provide favicon support typically display a page’s favicon in the browser’s address
bar (sometimes in the history as well) and next to the page’s name in a list of bookmarks.
Browsers that support a tabbed document interface typically show a page’s favicon next to the
page’s title on the tab
Some services in the cloud to generate favicons:
• Favicon Generator
• favicon.cc
En index.html poner una l´ınea como una de estas:
<link rel="shortcut icon" href="etsiiull.png" type="image/x-icon">
<link rel="shortcut icon" href="logo.png" />
<link href="images/favicon.ico" rel="icon" type="image/x-icon" />
1.5.
Ejercicios
1. Par´entesis:
> str = "John Smith"
’John Smith’
> newstr = str.replace(re, "$2, $1")
’Smith, John’
2. El m´etodo exec.
If your regular expression uses the g flag, you can use the exec method multiple times to find
successive matches in the same string. When you do so, the search starts at the substring of str
specified by the regular expression’s lastIndex property.
53
> re = /d(b+)(d)/ig
/d(b+)(d)/gi
> z = "dBdxdbbdzdbd"
’dBdxdbbdzdbd’
> result = re.exec(z)
[ ’dBd’, ’B’, ’d’, index: 0, input: ’dBdxdbbdzdbd’ ]
> re.lastIndex
3
> result = re.exec(z)
[ ’dbbd’, ’bb’, ’d’, index: 4, input: ’dBdxdbbdzdbd’ ]
> re.lastIndex
8
> result = re.exec(z)
[ ’dbd’, ’b’, ’d’, index: 9, input: ’dBdxdbbdzdbd’ ]
> re.lastIndex
12
> z.length
12
> result = re.exec(z)
null
3. JavaScript tiene lookaheads:
> x = "hello"
’hello’
> r = /l(?=o)/
/l(?=o)/
> z = r.exec(x)
[ ’l’, index: 3, input: ’hello’ ]
4. JavaScript no tiene lookbehinds:
> x = "hello"
’hello’
> r = /(?<=l)l/
SyntaxError: Invalid regular expression: /(?<=l)l/: Invalid group
> .exit
[~/Dropbox/src/javascript/PLgrado/csv(master)]$ irb
ruby-1.9.2-head :001 > x = "hello"
=> "hello"
ruby-1.9.2-head :002 > r = /(?<=l)l/
=> ll
ruby-1.9.2-head :008 > x =~ r
=> 3
ruby-1.9.2-head :009 > $&
=> "l"
5. El siguiente ejemplo comprueba la validez de n´
umeros de tel´efono:
[~/local/src/javascript/PLgrado/regexp]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/regexp
[~/local/src/javascript/PLgrado/regexp]$ cat phone.html
54
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<meta http-equiv="Content-Script-Type" content="text/javascript">
<script type="text/javascript">
var re = /\(?\d{3}\)?([-\/\.])\d{3}\1\d{4}/;
function testInfo(phoneInput){
var OK = re.exec(phoneInput.value);
if (!OK)
window.alert(RegExp.input + " isn’t a phone number with area code!");
else
window.alert("Thanks, your phone number is " + OK[0]);
}
</script>
</head>
<body>
<p>Enter your phone number (with area code) and then click "Check".
<br>The expected format is like ###-###-####.</p>
<form action="#">
<input id="phone"><button onclick="testInfo(document.getElementById(’phone’));">Chec
</form>
</body>
</html>
6. ¿Con que cadenas casa la expresi´
on regular /^(11+)\1+$/?
> ’1111’.match(/^(11+)\1+$/) # 4 unos
[ ’1111’,
’11’,
index: 0,
input: ’1111’ ]
> ’111’.match(/^(11+)\1+$/) # 3 unos
null
> ’11111’.match(/^(11+)\1+$/) # 5 unos
null
> ’111111’.match(/^(11+)\1+$/) # 6 unos
[ ’111111’,
’111’,
index: 0,
input: ’111111’ ]
> ’11111111’.match(/^(11+)\1+$/) # 8 unos
[ ’11111111’,
’1111’,
index: 0,
input: ’11111111’ ]
> ’1111111’.match(/^(11+)\1+$/)
null
>
Busque una soluci´on al siguiente ejercicio (v´ease ’Regex to add space after punctuation sign’ en
PerlMonks) Se quiere poner un espacio en blanco despu´es de la aparici´on de cada coma:
7. > x = "a,b,c,1,2,d, e,f"
55
’a,b,c,1,2,d, e,f’
> x.replace(/,/g,", ")
’a, b, c, 1, 2, d, e, f’
pero se quiere que la sustituci´
on no tenga lugar si la coma esta incrustada entre dos d´ıgitos.
Adem´
as se pide que si hay ya un espacio despu´es de la coma, no se duplique.
a) La siguiente soluci´on logra el segundo objetivo, pero estropea los n´
umeros:
> x = "a,b,c,1,2,d, e,f"
’a,b,c,1,2,d, e,f’
> x.replace(/,(\S)/g,", $1")
’a, b, c, 1, 2, d, e, f’
b) Esta otra funciona bien con los n´
umeros pero no con los espacios ya existentes:
> x = "a,b,c,1,2,d, e,f"
’a,b,c,1,2,d, e,f’
> x.replace(/,(\D)/g,", $1")
’a, b, c,1,2, d, e, f’
c) Explique cuando casa esta expresi´
on regular:
> r = /(\d[,.]\d)|(,(?=\S))/g
/(\d[,.]\d)|(,(?=\S))/g
Aproveche que el m´etodo replace puede recibir como segundo argumento una funci´on (vea
replace):
> z = "a,b,1,2,d, 3,4,e"
’a,b,1,2,d, 3,4,e’
> f = function(match, p1, p2, offset, string) { return (p1 || p2 + " "); }
[Function]
> z.replace(r, f)
’a, b, 1,2, d, 3,4, e’
1.6.
Pr´
actica: Palabras Repetidas
Se trata de producir una salida en las que las palabras repetidas consecutivas sean reducidas a una
sola aparici´on. Rellena las partes que faltan.
Donde
[~/srcPLgrado/repeatedwords(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/repeatedwords
[~/srcPLgrado/repeatedwords(master)]$ git remote -v
origin ssh:[email protected]/casiano/pl-grado-repeated-words.git (fetch)
origin ssh:[email protected]/casiano/pl-grado-repeated-words.git (push)
V´ease: https://bitbucket.org/casiano/pl-grado-repeated-words
Ejemplo de ejecuci´
on
Estructura
56
index.html
[~/Dropbox/src/javascript/PLgrado/repeatedwords(master)]$ cat index.html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>File Input</title>
<link href="global.css" rel="stylesheet" type="text/css">
<script type="text/javascript" src="../../underscore/underscore.js"></script>
<script type="text/javascript" src="../../jquery/starterkit/jquery.js"></script>
<script type="text/javascript" src="repeated_words.js"></script>
</head>
<body>
<h1>File Input</h1>
<input type="file" id="fileinput" />
<div id="out" class="hidden">
<table>
<tr><th>Original</th><th>Transformed</th></tr>
<tr>
<td>
<pre class="input" id="initialinput"></pre>
</td>
<td>
<pre class="output" id="finaloutput"></pre>
</td>
</tr>
</table>
</div>
</body>
</html>
1. Tag input
global.css
Rellena los estilos para hidden y unhidden:
[~/Dropbox/src/javascript/PLgrado/repeatedwords(master)]$ cat global.css
html *
{
font-size: large;
/* The !important ensures that nothing can override what you’ve set in this style
(unless it is also important). */
font-family: Arial;
}
.thumb {
height: 75px;
border: 1px solid #000;
margin: 10px 5px 0 0;
}
h1
th, td
{ text-align: center; font-size: x-large; }
{ vertical-align: top; text-align: right; }
57
/* #finaltable
* { color: white; background-color: black; }
/* #finaltable table { border-collapse:collapse; } */
/* #finaltable table, td { border:1px solid white; } */
#finaltable:hover td { background-color: blue; }
tr:nth-child(odd)
{ background-color:#eee; }
tr:nth-child(even)
{ background-color:#00FF66; }
input
{ text-align: right; border: none;
}
textarea
{ border: outset; border-color: white;
table
{ border: inset; border-color: white; }
.hidden
{ display: ____; }
.unhidden
{ display: _____; }
table.center { margin-left:auto; margin-right:auto; }
#result
{ border-color: red; }
tr.error
{ background-color: red; }
pre.output
{ background-color: white; }
span.repeated { background-color: red }
body
{
background-color:#b0c4de;
*/
/* Align input to the right
}
/* blue */
1. CSS display Property
2. Diferencias entre ”Display ”Visibility”
2
repeated words.js
Rellena las expresiones regulares que faltan:
[~/srcPLgrado/repeatedwords(master)]$ cat repeated_words.js
"use strict"; // Use ECMAScript 5 strict mode in browsers that support it
$(document).ready(function() {
$("#fileinput").change(calculate);
});
function generateOutput(contents) {
return contents.replace(/____________________/__,’__________________________________’);
}
function calculate(evt) {
var f = evt.target.files[0];
var contents = ’’;
if (f) {
var r = new FileReader();
r.onload = function(e) {
contents = e.target.result;
var escaped = escapeHtml(contents);
var outdiv = document.getElementById("out");
outdiv.className = ’unhidden’;
finaloutput.innerHTML = generateOutput(escaped);
initialinput.innerHTML = escaped;
58
*/
}
r.readAsText(f);
} else {
alert("Failed to load file");
}
}
var entityMap = {
"&": "&amp;",
"<": "&lt;",
">": "&gt;",
’"’: ’&quot;’,
"’": ’&#39;’,
"/": ’&#x2F;’
};
function escapeHtml(string) {
return String(string).replace(/_________/g, function (s) {
return ____________;
});
1. jQuery event.target
2. HTML 5 File API
3. HTML 5 File API: FileReader
4. HTML 5 File API: FileReader
5. element.className
6. HTML Entities
7. Tutorials:Getting Started with jQuery
8. Underscore: template
Ficheros de Entrada
[~/Dropbox/src/javascript/PLgrado/repeatedwords(master)]$ cat input2.txt
habia una vez
vez un viejo viejo
hidalgo que vivia
vivia
[~/Dropbox/src/javascript/PLgrado/repeatedwords(master)]$ cat input.txt
one one
nothing rep
is two three
three four
[~/Dropbox/src/javascript/PLgrado/repeatedwords(master)]$ cat inputhtml1.txt
habia => una vez
vez & un viejo viejo <puchum>
hidalgo & <pacham> que vivia
vivia </que se yo>
59
1.7.
Ejercicios
El formato INI es un formato estandar para la escritura de ficheros de configuraci´
on. Su estrucutra
b´asica se compone de ”secciones ”propiedades”. V´ease la entrada de la wikipedia INI.
2
; last modified 1 April 2001 by John Doe
[owner]
name=John Doe
organization=Acme Widgets Inc.
[database]
; use IP address in case network name resolution is not working
server=192.0.2.62
port=143
file = "payroll.dat"
1. Escriba un programa javascript que obtenga las cabeceras de secci´
on de un fichero INI
2. Escriba un programa javascript que case con los bloques de un fichero INI (cabecera mas lista
de pares par´
ametro=valor)
3. Se quieren obtener todos los pares nombre-valor, usando par´entesis con memoria para capturar
cada parte.
4. ¿Que casa con cada par´entesis en esta regexp para los pares nombre-valor?
> x = "h
= 4"
> r = /([^=]*)(\s*)=(\s*)(.*)/
> r.exec(x)
>
1.8.
Ejercicios
1. Escriba una expresi´
on regular que reconozca las cadenas de doble comillas. Debe permitir la
presencia de comillas y caracteres escapados.
2. ¿Cual es la salida?
> "bb".match(/b|bb/)
> "bb".match(/bb|b/)
1.9.
Pr´
actica: Ficheros INI
Donde
[~/srcPLgrado/ini(develop)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/ini
[~/srcPLgrado/ini(develop)]$ git remote -v
origin ssh:[email protected]/casiano/pl-grado-ini-files.git (fetch)
origin ssh:[email protected]/casiano/pl-grado-ini-files.git (push)
V´ease
Repositorio conteniendo el c´odigo (inicial) del analizador de ficheros ini: https://github.com/crguezl/pl-grado
Despliegue en GitHub pages: http://crguezl.github.io/pl-grado-ini-files/
Repositorio privado del profesor: https://bitbucket.org/casiano/pl-grado-ini-files/src.
60
index.html
[~/javascript/PLgrado/ini(master)]$ cat index.html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>INI files</title>
<link href="global.css" rel="stylesheet" type="text/css">
<!-<link rel="shortcut icon" href="logo.png" />
-->
<link rel="shortcut icon" href="etsiiull.png" type="image/x-icon">
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
<script type="text/javascript" src="ini.js"></script>
</head>
<body>
<h1>INI files</h1>
<input type="file" id="fileinput" />
<div id="out" class="hidden">
<table>
<tr><th>Original</th><th>Tokens</th></tr>
<tr>
<td>
<pre class="input" id="initialinput"></pre>
</td>
<td>
<pre class="output" id="finaloutput"></pre>
</td>
</tr>
</table>
</div>
</body>
</html>
Ficheros
Vease
Reading files in JavaScript using the File APIs by Eric Bidelman.
Source code in files-in-javascript-tut
W3C File API
Ejemplo FileList en
• github
• en acci´on en gh-pages.
• Tambien en jsfiddle
• o bien
[~/src/javascript/fileapi/html5rocks]$ pwd -P
/Users/casiano/local/src/javascript/fileapi/html5rocks
[~/src/javascript/fileapi/html5rocks(master)]$ ls -l filelist.html
61
-rw-r--r--
1 casiano
staff
767 15 feb 17:21 filelist.html
• The EventTarget.addEventListener() method
target.addEventListener(type, listener[, useCapture]);
registers the specified listener on the EventTarget it’s called on. The event target may
be an Element in a document, the Document itself, a Window, or any other object that
supports events (such as XMLHttpRequest).
•
> date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
Wed Dec 12 2012 03:00:00 GMT+0000 (WET)
> date.toLocaleDateString()
"12/12/2012"
• Date.prototype.toLocaleDateString()
Ejemplo de Drag and Drop en
• GitHub
• gh-pages
• jsfiddle
o bien en:
[~/src/javascript/fileapi/html5rocks]$ pwd -P
/Users/casiano/local/src/javascript/fileapi/html5rocks
[~/src/javascript/fileapi/html5rocks]$ ls -l dragandrop.html
-rw-r--r-- 1 casiano staff 1535 15 feb 18:25 dragandrop.html
• stopPropagation stops the event from bubbling up the event chain.
Suppose you have a table and within that table you have an anchor tag. Both the table
and the anchor tag have code to handle mouse clicks. When the user clicks on the anchor
tag, which HTML element should process the event first? Should it be the table then the
anchor tag or vice versa?
Formally, the event path is broken into three phases.
◦ In the capture phase, the event starts at the top of the DOM tree, and propagates
through to the parent of the target.
◦ In the target phase, the event object arrives at its target. This is generally where you
will write your event-handling code.
◦ In the bubble phase, the event will move back up through the tree until it reaches the
top. Bubble phase propagation happens in reverse order to the capture phase, with an
event starting at the parent of the target and ending up back at the top of the DOM
tree.
◦ jsfiddle
These days, there’s a choice to register an event in either the capture phase or the bubble
phase. If you register an event in the capture phase, the parent element will process the
event before the child element.
• preventDefault prevents the default action the browser makes on that event.
After you’ve obtained a File reference, instantiate a FileReader object to read its contents into
memory.
62
var reader = new FileReader();
to read the file we call one of the readAs... For example readAsDataURL is used to starts reading
the contents of the specified Blob or File:
reader.readAsDataURL(f);
Methods to remember:
• FileReader.abort() Aborts the read operation. Upon return, the readyState will be
DONE.
• FileReader.readAsArrayBuffer() Starts reading the contents of the specified Blob, once
finished, the result attribute contains an ArrayBuffer representing the file’s data.
• FileReader.readAsBinaryString() Starts reading the contents of the specified Blob, once
finished, the result attribute contains the raw binary data from the file as a string.
• FileReader.readAsDataURL() Starts reading the contents of the specified Blob.
When the read operation is finished, the readyState becomes DONE, and the loadend is
triggered. At that time, the result attribute contains a URL representing the file’s data as
base64 encoded string.
• FileReader.readAsText() Starts reading the contents of the specified Blob, once finished,
the result attribute contains the contents of the file as a text string.
Once one of these read methods is called on your FileReader object, the onloadstart, onprogress,
onload, onabort, onerror, and onloadend can be used to track its progress.
When the load finishes, the reader’s onload event is fired and its result attribute can be used to
access the file data.
reader.onload = function(e) {
var contents = e.target.result;
....
}
See
•
•
•
•
jsfiddle
GitHub
gh-pages
or
[~/src/javascript/fileapi/html5rocks]$ pwd -P
/Users/casiano/local/src/javascript/fileapi/html5rocks
[~/src/javascript/fileapi/html5rocks]$ ls -l readimages.html
-rw-r--r-- 1 casiano staff 1530 15 feb 21:00 readimages.html
• base64 testing image jsfiddle
• The insertBefore() method inserts a node as a child, right before an existing child, which
you specify. See
[~/src/javascript/fileapi/html5rocks]$ ls -l readimages.html
-rw-r--r-- 1 casiano staff 1530 15 feb 21:00 readimages.html
63
global.css
[~/javascript/PLgrado/ini(master)]$ cat global.css
html *
{
font-size: large;
/* The !important ensures that nothing can override what you’ve set in this style (unless i
font-family: Arial;
}
.thumb {
height: 75px;
border: 1px solid #000;
margin: 10px 5px 0 0;
}
h1
{ text-align: center; font-size: x-large; }
th, td
{ vertical-align: top; text-align: left; }
/* #finaltable * { color: white; background-color: black; }
/* #finaltable table { border-collapse:collapse; } */
/* #finaltable table, td { border:1px solid white; } */
#finaltable:hover td { background-color: blue; }
tr:nth-child(odd)
{ background-color:#eee; }
tr:nth-child(even)
{ background-color:#00FF66; }
input
{ text-align: right; border: none;
}
textarea
{ border: outset; border-color: white;
table
{ border: inset; border-color: white; }
.hidden
{ display: none; }
.unhidden
{ display: block; }
table.center { margin-left:auto; margin-right:auto; }
#result
{ border-color: red; }
tr.error
{ background-color: red; }
pre.output
{ background-color: white; }
/*
span.repeated { background-color: red }
span.header { background-color: blue }
span.comments { background-color: orange }
span.blanks { background-color: green }
span.nameEqualValue { background-color: cyan }
span.error { background-color: red }
*/
body
{
background-color:#b0c4de; /* blue */
}
/* Align input to the right
}
Ficheros de Prueba
~/Dropbox/src/javascript/PLgrado/ini(master)]$ cat input.ini
; last modified 1 April 2001 by John Doe
[owner]
name=John Doe
organization=Acme Widgets Inc.
64
*/
*/
[database]
; use IP address in case network name resolution is not working
server=192.0.2.62
port=143
file = "payroll.dat"
$ cat input2.ini
[special_fields]
required = "EmailAddr,FirstName,LastName,Mesg"
csvfile = "contacts.csv"
csvcolumns = "EmailAddr,FirstName,LastName,Mesg,Date,Time"
[email_addresses]
sales = "[email protected],[email protected],[email protected]"
$ cat inputerror.ini
[owner]
name=John Doe
organization$Acme Widgets Inc.
[database
; use IP address in case network name resolution is not working
server=192.0.2.62
port=143
file = "payroll.dat"
ini.js
[~/javascript/PLgrado/ini(master)]$ cat ini.js
"use strict"; // Use ECMAScript 5 strict mode in browsers that support it
$(document).ready(function() {
$("#fileinput").change(calculate);
});
function calculate(evt) {
var f = evt.target.files[0];
if (f) {
var r = new FileReader();
r.onload = function(e) {
var contents = e.target.result;
var tokens = lexer(contents);
var pretty = tokensToString(tokens);
out.className = ’unhidden’;
initialinput.innerHTML = contents;
finaloutput.innerHTML = pretty;
}
r.readAsText(f);
} else {
alert("Failed to load file");
65
}
}
var temp = ’<li> <span class = "<%= token.type %>"> <%= match %> </span>\n’;
function tokensToString(tokens) {
var r = ’’;
for(var i=0; i < tokens.length; i++) {
var t = tokens[i]
var s = JSON.stringify(t, undefined, 2);
s = _.template(temp, {token: t, match: s});
r += s;
}
return ’<ol>\n’+r+’</ol>’;
}
function lexer(input) {
var blanks
= /^\s+/;
var iniheader
= /^\[([^\]\r\n]+)\]/;
var comments
= /^[;#](.*)/;
var nameEqualValue = /^([^=;\r\n]+)=([^;\r\n]*)/;
var any
= /^(.|\n)+/;
var out = [];
var m = null;
while (input != ’’) {
if (m = blanks.exec(input)) {
input = input.substr(m.index+m[0].length);
out.push({ type : ’blanks’, match: m });
}
else if (m = iniheader.exec(input)) {
input = input.substr(m.index+m[0].length);
out.push({ type: ’header’, match: m });
}
else if (m = comments.exec(input)) {
input = input.substr(m.index+m[0].length);
out.push({ type: ’comments’, match: m });
}
else if (m = nameEqualValue.exec(input)) {
input = input.substr(m.index+m[0].length);
out.push({ type: ’nameEqualValue’, match: m });
}
else if (m = any.exec(input)) {
out.push({ type: ’error’, match: m });
input = ’’;
}
else {
alert("Fatal Error!"+substr(input,0,20));
input = ’’;
}
}
return out;
66
}
V´ease la secci´
on JSON.stringify() 1.3 para saber mas sobre JSON.stringify.
Dudas sobre la Sint´
axis del Formato INI
La sint´axis de INI no est´a bien definida. Se aceptan
decisiones razonables para cada una de las expresiones regulares. Si quiere ver un parser en acci´on
puede instalar la gema inifile (Ruby).
Una opci´
on que no hemos contemplado en nuestro c´odigo es la posibilidad de hacer que una l´ınea
de asignaci´
on se expanda en varias l´ıneas. En inifile el car´acter \ indica que la l´ınea contin´
ua en la
siguiente:
[~/javascript/PLgrado/inifile(master)]$ cat test/data/good.ini
[section_one]
one = 1
two = 2
[section_two]
three =
3
multi = multiline \
support
; comments should be ignored
[section three]
four
=4
five=5
six =6
[section_four]
[section_five]
seven and eight= 7 & 8
[~/javascript/PLgrado/inifile(master)]$ pry
[2] pry(main)> require ’inifile’
=> true
[3] pry(main)> p = IniFile.new(:filename => ’test/data/good.ini’)
=> #<IniFile:0x007fba2f41a500
@_line=" seven and eight= 7 & 8",
@_section={"seven and eight"=>"7 & 8"},
@comment=";#",
@content=
"[section_one]\none = 1\ntwo = 2\n\n[section_two]\nthree =
@default="global",
@encoding=nil,
@escape=true,
@filename="test/data/good.ini",
@ini=
{"section_one"=>{"one"=>"1", "two"=>"2"},
"section_two"=>{"three"=>"3", "multi"=>"multiline support"},
"section three"=>{"four"=>"4", "five"=>"5", "six"=>"6"},
"section_four"=>{},
"section_five"=>{"seven and eight"=>"7 & 8"}},
@param="=">
67
3\nmulti = multiline \\\n
[4] pry(main)> p["section_two"]
=> {"three"=>"3", "multi"=>"multiline support"}
[5] pry(main)> p[:section_two]
Tareas
Es conveniente que consiga estos objetivos:
Pueden comenzar haciendo un fork del repositorio https://github.com/crguezl/pl-grado-ini-files.
La entrada deber´ıa poder leerse desde un fichero. A˜
nada drag and drop.
Use Web Storage igual que en la anterior
Escriba las pruebas
Use templates externos underscore para estructurar la salida
A˜
nada soporte para multil´ıneas en las asignaciones (V´ease la secci´
on 1.9)
> s = ’a=b\\\nc’
’a=b\\\nc’
> n2 = /^([^=;#\r\n]+)=((?:[^;#\r\n]*\\\n)*[^;#\r\n]*)/
/^([^=;#\r\n]+)=((?:[^;#\r\n]*\\\n)*[^;#\r\n]*)/
> m = n2.exec(s)
[ ’a=b\\\nc’, ’a’, ’b\\\nc’,
index: 0, input: ’a=b\\\nc’ ]
> d = m[2]
’b\\\nc’
> d.replace(/\\\n/g,’ ’)
’b c’
V´
ease
1. JSON.stringify
2. www.json.org
3. JSON in JavaScript
4. Underscore: template
5. Stackoverflow::how to use Underscore template
1.10.
Pr´
actica: Analizador L´
exico para Un Subconjunto de JavaScript
TDOP, Top Down Operator Precedence
Crockford:
Vamos a trabajar a partir de este repo de Douglas
https://github.com/douglascrockford/TDOP
Autor: Douglas Crockford, [email protected]
Fecha que figura en el repo: 2010-11-12
Descripci´
on:
68
• tdop.html contains a description of Vaughn Pratt’s Top Down Operator Precedence, and
describes the parser whose lexer we are going to write in this lab. Is a simplified version of
JavaScript.
• The file index.html parses parse.js and displays its AST.
• The page depends on on parse.js and tokens.js.
• The file tdop.js contains the Simplified JavaScript parser.
• tokens.js. produces an array of token objects from a string. This is the file we are going to
work in this lab.
Objetivos de la Pr´
actica
Douglas Crockford escribi´
o su analizador l´exico tokens.js sin usar expresiones regulares. Eso hace
que sea extenso (268 l´ıneas). Su analizador es un subconjunto de JS que no tiene - entre otras cosas expresiones regulares ya que uno de sus objetivos era que el analizador se analizara a si mismo.
Reescriba el analizador l´exico en tokens.js. usando expresiones regulares.
1. Evite que se hagan copias de la cadena siendo procesada. Mu´evase dentro de la misma cadena
usando lastIndex
2. A˜
nada botones/enlaces/menu de selecci´
on que permitan cargar un fichero espec´ıfico de una lista
de ficheros en la texarea de entrada.
Vea el ejemplo en https://github.com/crguezl/loadfileontotexarea.
En este caso en vez de un fichero index.html arrancamos desde un programa Ruby app.rb.
Para verlo en ejecuci´
on instale primero las dependencias:
[~/javascript/jquery/loadfileontotexarea(master)]$ bundle install
Using daemons (1.1.9)
Using eventmachine (1.0.3)
Using rack (1.5.2)
Using rack-protection (1.5.2)
Using tilt (1.4.1)
Using sinatra (1.4.4)
Using thin (1.6.1)
Using bundler (1.3.5)
Your bundle is complete!
Use ‘bundle show [gemname]‘ to see where a bundled gem is installed.
Para ejecutar puede llamar a la aplicaci´on as´ı:
[~/javascript/jquery/loadfileontotexarea(master)]$ bundle exec rackup
Thin web server (v1.6.1 codename Death Proof)
Maximum connections set to 1024
Listening on 0.0.0.0:9292, CTRL+C to stop
Ahora visite en su navegador la URL http://localhost:9292.
Puede ver tambi´en la aplicaci´on corriendo en los servidores de Heroku en http://pllexer.herokuapp.com/.
Visite los enlaces withajax.html y withget.html.
3. A˜
nada pruebas
4. Haga el despliegue de su aplicaci´on en Heroku. Para ver como hacerlo siga las indicaciones en la
secci´
on Heroku ?? en estos apuntes
5. Una primera soluci´on de la que puede partir se encuentra en: https://github.com/crguezl/ull-etsii-grado-pl-mi
en github. Veala en funcionamiento en GitHub Pages
69
6. El m´etodo tokens retorna el array de tokens. Puede encontrarlo en tokens.js.
7. Mejore la soluci´on en https://github.com/crguezl/ull-etsii-grado-pl-minijavascript/tree/gh-pages
8. Para esta pr´actica es necesario familiarizarse con la forma en que funciona la OOP en JS. Vea
este jsfiddle
70
Cap´ıtulo 2
Analizadores Descendentes Predictivos
en JavaScript
2.1.
Conceptos B´
asicos para el An´
alisis Sint´
actico
Suponemos que el lector de esta secci´
on ha realizado con ´exito un curso en teor´ıa de aut´omatas y
lenguajes formales. Las siguientes definiciones repasan los conceptos mas importantes.
n
Definici´
on 2.1.1. Dado un conjunto A, se define A∗ el cierre de Kleene de A como: A∗ = ∪∞
n=0 A
Se admite que A0 = {ǫ}, donde ǫ denota la palabra vac´ıa, esto es la palabra que tiene longitud
cero, formada por cero s´ımbolos del conjunto base A.
Definici´
on 2.1.2. Una gram´
atica G es una cuaterna G = (Σ, V, P, S). Σ es el conjunto de terminales.
V es un conjunto (disjunto de Σ) que se denomina conjunto de variables sint´acticas o categor´ıas
gram´aticales, P es un conjunto de pares de V × (V ∪ Σ)∗ . En vez de escribir un par usando la notaci´
on
(A, α) ∈ P se escribe A → α. Un elemento de P se denomina producci´
on. Por u
´ltimo, S es un s´ımbolo
del conjunto V que se denomina s´ımbolo de arranque.
Definici´
on 2.1.3. Dada una gram´
atica G = (Σ, V, P, S) y µ = αAβ ∈ (V ∪ Σ)∗ una frase formada
por variables y terminales y A → γ una producci´
on de P , decimos que µ deriva en un paso en αγβ.
Esto es, derivar una cadena αAβ es sustituir una variable sint´
actica A de V por la parte derecha γ
de una de sus reglas de producci´
on. Se dice que µ deriva en n pasos en δ si deriva en n − 1 pasos en
∗
una cadena αAβ la cual deriva en un paso en δ. Se escribe entonces que µ =⇒ δ. Una cadena deriva
en 0 pasos en si misma.
Definici´
on 2.1.4. Dada una gram´
atica G = (Σ, V, P, S) se denota por L(G) o lenguaje generado por
G al lenguaje:
∗
L(G) = {x ∈ Σ∗ : S =⇒ x}
Esto es, el lenguaje generado por la gram´
atica G esta formado por las cadenas de terminales que
pueden ser derivados desde el s´ımbolo de arranque.
Definici´
on 2.1.5. Una derivaci´
on que comienza en el s´ımbolo de arranque y termina en una secuencia
formada por s´
olo terminales de Σ se dice completa.
∗
Una derivaci´
on µ =⇒ δ en la cual en cada paso αAx la regla de producci´
on aplicada A → γ se
aplica en la variable sint´
actica mas a la derecha se dice una derivaci´
on a derechas
∗
Una derivaci´
on µ =⇒ δ en la cual en cada paso xAα la regla de producci´
on aplicada A → γ se
aplica en la variable sint´
actica mas a la izquierda se dice una derivaci´
on a izquierdas
Definici´
on 2.1.6. Observe que una derivaci´
on puede ser representada como un a
´rbol cuyos nodos
est´
an etiquetados en V ∪ Σ. La aplicaci´
on de la regla de producci´
on A → γ se traduce en asignar como
hijos del nodo etiquetado con A a los nodos etiquetados con los s´ımbolos X1 . . . Xn que constituyen la
frase γ = X1 . . . Xn . Este ´
arbol se llama ´
arbol sint´actico concreto asociado con la derivaci´
on.
71
Definici´
on 2.1.7. Observe que, dada una frase x ∈ L(G) una derivaci´
on desde el s´ımbolo de arranque
da lugar a un ´
arbol. Ese ´
arbol tiene como ra´ız el s´ımbolo de arranque y como hojas los terminales
x1 . . . xn que forman x. Dicho ´
arbol se denomina ´arbol de an´
alisis sint´actico concreto de x. Una
derivaci´
on determina una forma de recorrido del ´
arbol de an´
alisis sint´
actico concreto.
Definici´
on 2.1.8. Una gram´
atica G se dice ambigua si existe alguna frase x ∈ L(G) con al menos
dos ´
arboles sint´
acticos. Es claro que esta definici´
on es equivalente a afirmar que existe alguna frase
x ∈ L(G) para la cual existen dos derivaciones a izquierda (derecha) distintas.
2.1.1.
Ejercicio
Dada la gram´atica con producciones:
program → declarations statements | statements
declarations → declaration ’;’ declarations | declaration ’;’
declaration → INT idlist | STRING idlist
statements → statement ’;’ statements | statement
statement → ID ’=’ expression | P expression
expression → term ’+’ expression | term
term → factor ’*’ term | factor
factor → ’(’ expression ’)’ | ID | NUM | STR
idlist → ID ’,’ idlist | ID
En esta gram´atica, Σ esta formado por los caracteres entre comillas simples y los s´ımbolos cuyos
identificadores est´an en may´
usculas. Los restantes identificadores corresponden a elementos de V . El
s´ımbolo de arranque es S = program.
Conteste a las siguientes cuestiones:
1. Describa con palabras el lenguaje generado.
2. Construya el ´
arbol de an´
alisis sint´actico concreto para cuatro frases del lenguaje.
3. Se˜
nale a que recorridos del ´
arbol corresponden las respectivas derivaciones a izquierda y a derecha
en el apartado 2.
4. ¿Es ambigua esta gram´atica?. Justifique su respuesta.
2.2.
An´
alisis Sint´
actico Predictivo Recursivo
La siguiente fase en la construcci´
on del analizador es la fase de an´
alisis sint´actico. Esta toma como
entrada el flujo de terminales y construye como salida el ´arbol de an´
alisis sint´actico abstracto.
El ´arbol de an´
alisis sint´actico abstracto es una representaci´
on compactada del ´arbol de an´
alisis
sint´actico concreto que contiene la misma informaci´
on que ´este.
Existen diferentes m´etodos de an´
alisis sint´actico. La mayor´ıa caen en una de dos categor´ıas: ascendentes y descendentes. Los ascendentes construyen el ´arbol desde las hojas hacia la ra´ız. Los
descendentes lo hacen en modo inverso. El que describiremos aqui es uno de los mas sencillos: se
denomina m´etodo de an´
alisis predictivo descendente recursivo.
2.2.1.
Introducci´
on
En este m´etodo se asocia una subrutina con cada variable sint´actica A ∈ V . Dicha subrutina (que
llamaremos A) reconocer´
a el lenguaje generado desde la variable A:
∗
LA (G) = {x ∈ Σ∗ : A =⇒ x}
72
statements → statement ’;’ statements | statement
statement → ID ’=’ expression | P expression
expression → term ’+’ expression | term
term → factor ’*’ term | factor
factor → ’(’ expression ’)’ | ID | NUM
Cuadro 2.1: Una Gram´atica Simple
En este m´etodo se escribe una rutina A por variable sint´actica A ∈ V . Se le da a la rutina asociada
el mismo nombre que a la variable sint´actica asociada.
La funci´on de la rutina A asociada con la variable A ∈ V es reconocer el lenguaje L(A) generado
por A.
La estrategia general que sigue la rutina A para reconocer L(A) es decidir en t´erminos del terminal
a en la entrada que regla de producci´
on concreta A → α se aplica para a continuaci´
on comprobar que
la entrada que sigue pertenece al lenguaje generado por α.
En un analizador predictivo descendente recursivo (APDR) se asume que el s´ımbolo que actualmente esta siendo observado (denotado habitualmente como lookahead) permite determinar un´ıvocamente
que producci´
on de A hay que aplicar.
Una vez que se ha determinado que la regla por la que continuar la derivaci´
on es A → α se procede
a reconocer Lα (G), el lenguaje generado por α. Si α = X1 . . . Xn , las apariciones de terminales Xi en
α son emparejadas con los terminales en la entrada mientras que las apariciones de variables Xi = B
en α se traducen en llamadas a la correspondiente subrutina asociada con B.
Ejemplo
Para ilustrar el m´etodo, simplificaremos la gram´atica presentada en el ejercicio 5.1.1 eliminando
las declaraciones:
La secuencia de llamadas cuando se procesa la entrada mediante el siguiente programa construye
impl´ıcitamente el ´
arbol de an´
alisis sint´
actico concreto.
parse = (input) ->
tokens = input.tokens()
lookahead = tokens.shift()
match = (t) ->
if lookahead.type is t
lookahead = tokens.shift()
lookahead = null if typeof lookahead is "undefined"
else # Error. Throw exception
throw "Syntax Error. Expected #{t} found ’" +
lookahead.value + "’ near ’" +
input.substr(lookahead.from) + "’"
return
statements = ->
result = [statement()]
while lookahead and lookahead.type is ";"
match ";"
result.push statement()
(if result.length is 1 then result[0] else result)
statement = ->
result = null
if lookahead and lookahead.type is "ID"
73
left =
type: "ID"
value: lookahead.value
match "ID"
match "="
right = expression()
result =
type: "="
left: left
right: right
else if lookahead and lookahead.type is "P"
match "P"
right = expression()
result =
type: "P"
value: right
else # Error!
throw "Syntax Error. Expected identifier but found " +
(if lookahead then lookahead.value else "end of input") +
" near ’#{input.substr(lookahead.from)}’"
result
expression = ->
result = term()
if lookahead and lookahead.type is "+"
match "+"
right = expression()
result =
type: "+"
left: result
right: right
result
term = ->
result = factor()
if lookahead and lookahead.type is "*"
match "*"
right = term()
result =
type: "*"
left: result
right: right
result
factor = ->
result = null
if lookahead.type is "NUM"
result =
type: "NUM"
value: lookahead.value
match "NUM"
74
else if lookahead.type is "ID"
result =
type: "ID"
value: lookahead.value
match "ID"
else if lookahead.type is "("
match "("
result = expression()
match ")"
else # Throw exception
throw "Syntax Error. Expected number or identifier or ’(’ but found " +
(if lookahead then lookahead.value else "end of input") +
" near ’" + input.substr(lookahead.from) + "’"
result
tree = statements(input)
if lookahead?
throw "Syntax Error parsing statements. " +
"Expected ’end of input’ and found ’" +
input.substr(lookahead.from) + "’"
tree
var parse = function(input) {
var tokens = input.tokens();
var lookahead = tokens.shift();
var match = function(t) {
if (lookahead.type === t) {
lookahead = tokens.shift();
if (typeof lookahead === ’undefined’) {
lookahead = null; // end of input
}
} else { // Error. Throw exception
throw "Syntax Error. Expected "+t+" found ’"+lookahead.value+
"’ near ’"+input.substr(lookahead.from)+"’";
}
};
var statements = function() {
var result = [ statement() ];
while (lookahead && lookahead.type === ’;’) {
match(’;’);
result.push(statement());
}
return result.length === 1? result[0] : result;
};
var statement = function() {
var result = null;
if (lookahead && lookahead.type === ’ID’) {
var left = { type: ’ID’, value: lookahead.value };
match(’ID’);
75
match(’=’);
right = expression();
result = { type: ’=’, left: left, right: right };
} else if (lookahead && lookahead.type === ’P’) {
match(’P’);
right = expression();
result = { type: ’P’, value: right };
} else { // Error!
throw "Syntax Error. Expected identifier but found "+
(lookahead? lookahead.value : "end of input")+
" near ’"+input.substr(lookahead.from)+"’";
}
return result;
};
var expression = function() {
var result = term();
if (lookahead && lookahead.type === ’+’) {
match(’+’);
var right = expression();
result = {type: ’+’, left: result, right: right};
}
return result;
};
var term = function() {
var result = factor();
if (lookahead && lookahead.type === ’*’) {
match(’*’);
var right = term();
result = {type: ’*’, left: result, right: right};
}
return result;
};
var factor = function() {
var result = null;
if (lookahead.type === ’NUM’) {
result = {type: ’NUM’, value: lookahead.value};
match(’NUM’);
}
else if (lookahead.type === ’ID’) {
result = {type: ’ID’, value: lookahead.value};
match(’ID’);
}
else if (lookahead.type === ’(’) {
match(’(’);
result = expression();
match(’)’);
} else { // Throw exception
throw "Syntax Error. Expected number or identifier or ’(’ but found "+
(lookahead? lookahead.value : "end of input")+
76
" near ’"+input.substr(lookahead.from)+"’";
}
return result;
};
var tree = statements(input);
if (lookahead != null) {
throw "Syntax Error parsing statements. Expected end of input and found ’"+
input.substr(lookahead.from)+"’";
}
return tree;
}
Caracterizaci´
on de las Gram´
aticas Analizables
Como vemos en el ejemplo, el an´
alisis predictivo conf´ıa en que, si estamos ejecutando la entrada del procedimiento A, el cu´
al est´a asociado con
la variable A ∈ V , el s´ımbolo terminal que esta en la entrada a determine de manera un´ıvoca la regla
de producci´
on A → aα que debe ser procesada.
Si se piensa, esta condici´
on requiere que todas las partes derechas α de las reglas A → α de A
comiencen por diferentes s´ımbolos. Para formalizar esta idea, introduciremos el concepto de conjunto
F IRST (α):
Definici´
on 2.2.1. Dada una gram´
atica G = (Σ, V, P, S) y un s´ımbolo α ∈ (V ∪ Σ)∗ se define el
conjunto F IRST (α)
n como:
o
∗
F IRST (α) = b ∈ Σ : α =⇒ bβ ∪ N (α)
donde:
∗
{ǫ} si α =⇒ ǫ
N (α) =
∅
en otro caso
Podemos reformular ahora nuestra afirmaci´on anterior en estos t´erminos: Si A → γ1 | . . . | γn y los
conjuntos F IRST (γi ) son disjuntos podemos construir el procedimiento para la variable A siguiendo
este seudoc´odigo:
A = function() {
if (lookahead in FIRST(gamma_1)) { imitar gamma_1 }
else if (lookahead in FIRST(gamma_2)) { imitar gamma_2 }
...
else (lookahead in FIRST(gamma_n)) { imitar gamma_n }
}
Donde si γj es X1 . . . Xk el c´odigo gamma_j consiste en una secuencia i = 1 . . . k de llamadas de
uno de estos dos tipos:
Llamar a la subrutina X_i si Xi es una variable sint´actica
Hacer una llamada a match(X_i) si Xi es un terminal
2.2.2.
Ejercicio: Recorrido del ´
arbol en un ADPR
¿En que forma es recorrido el ´
arbol de an´
alisis sint´actico concreto en un analizador descendente
predictivo recursivo? ¿En que orden son visitados los nodos?
2.3.
Recursi´
on por la Izquierda
∗
Definici´
on 2.3.1. Una gram´atica es recursiva por la izquierda cuando existe una derivaci´
on A =⇒
Aα.
En particular, es recursiva por la izquierda si contiene una regla de producci´
on de la forma A → Aα.
En este caso se dice que la recursi´
on por la izquierda es directa.
77
Cuando la gram´atica es recursiva por la izquierda, el m´etodo de an´
alisis recursivo descendente
predictivo no funciona. En ese caso, el procedimiento A asociado con A ciclar´ıa para siempre sin llegar
a consumir ning´
un terminal.
2.4.
Esquemas de Traducci´
on
Definici´
on 2.4.1. Un esquema de traducci´on es una gram´
atica independiente del contexto en la
cual se han insertado fragmentos de c´
odigo en las partes derechas de sus reglas de producci´
on. Los
fragmentos de c´
odigo asi insertados se denominan acciones sem´
anticas. Dichos fragmentos act´
uan,
calculan y modifican los atributos asociados con los nodos del ´
arbol sint´
actico. El orden en que se
eval´
uan los fragmentos es el de un recorrido primero-profundo del ´
arbol de an´
alisis sint´
actico.
Obs´ervese que, en general, para poder aplicar un esquema de traducci´on hay que construir el ´
arbol
sint´actico y despu´es aplicar las acciones empotradas en las reglas en el orden de recorrido primeroprofundo. Por supuesto, si la gram´atica es ambigua una frase podr´ıa tener dos ´arboles y la ejecuci´
on
de las acciones para ellos podr´ıa dar lugar a diferentes resultados. Si se quiere evitar la multiplicidad
de resultados (interpretaciones sem´
anticas) es necesario precisar de que ´arbol sint´actico concreto se
esta hablando.
Por ejemplo, si en la regla A → αβ insertamos un fragmento de c´odigo:
A → α{action}β
La acci´on {action} se ejecutar´
a despu´es de todas las acciones asociadas con el recorrido del sub´
arbol
de α y antes que todas las acciones asociadas con el recorrido del sub´arbol β.
El siguiente esquema de traducci´on recibe como entrada una expresi´
on en infijo y produce como
salida su traducci´on a postfijo para expresiones aritmeticas con s´
olo restas de n´
umeros:
expr → expr1 − N U M
expr → N U M
{ expr.TRA = expr[1].TRA+" "+NUM.VAL+" - "}
{ expr.TRA = NUM.VAL }
Las apariciones de variables sint´acticas en una regla de producci´
on se indexan como se ve en el
ejemplo, para distinguir de que nodo del ´arbol de an´
alisis estamos hablando. Cuando hablemos del
atributo de un nodo utilizaremos el punto (.). Aqu´ı VAL es un atributo de los nodos de tipo N U M
denotando su valor num´erico y para accederlo escribiremos NUM.VAL. An´
alogamente expr.TRA denota
el atributo traducci´on de los nodos de tipo expr.
Ejercicio 2.4.1. Muestre la secuencia de acciones a la que da lugar el esquema de traducci´
on anterior
para la frase 7 -5 -4.
En este ejemplo, el c´omputo del atributo expr.TRA depende de los atributos en los nodos hijos,
o lo que es lo mismo, depende de los atributos de los s´ımbolos en la parte derecha de la regla de
producci´
on. Esto ocurre a menudo y motiva la siguiente definici´on:
Definici´
on 2.4.2. Un atributo tal que su valor en todo nodo del ´
arbol sint´
actico puede ser computado
en t´erminos de los atributos de los hijos del nodo se dice que es un atributo sintetizado.
2.5.
Eliminaci´
on de la Recursi´
on por la Izquierda en un Esquema
de Traducci´
on
La eliminaci´on de la recursi´on por la izquierda es s´
olo un paso: debe ser extendida a esquemas de
traducci´on, de manera que no s´
olo se preserve el lenguaje sino la secuencia de acciones. Supongamos
que tenemos un esquema de traducci´on de la forma:
A → Aα
A → Aβ
A→γ
{ alpha_action }
{ beta_action }
{ gamma_action }
78
para una sentencia como γβα la secuencia de acciones ser´a:
gamma_action
beta_action alpha_action
¿C´omo construir un esquema de traducci´on para la gram´atica resultante de eliminar la recursi´on
por la izquierda que ejecute las acciones asociadas en el mismo orden?. Supongamos para simplificar,
que las acciones no dependen de atributos ni computan atributos, sino que act´
uan sobre variables
globales. En tal caso, la siguiente ubicaci´
on de las acciones da lugar a que se ejecuten en el mismo
orden:
A → γ { gamma_action } R
R → β { beta_action } R
R → α { alpha_action } R
R→ǫ
Si hay atributos en juego, la estrategia para construir un esquema de traducci´on equivalente para
la gram´atica resultante de eliminar la recursividad por la izquierda se complica.
2.6.
Pr´
actica: Analizador Descendente Predictivo Recursivo
Partiendo del analizador sint´actico descendente predictivo recursivo para la gram´atica descrita en
la secci´
on 2.2.1
Donde
Puede encontrar la versi´
on de la que partir en
Despliegue en Heroku: http://predictiveparser.herokuapp.com/
Repositorio en GitHub: https://github.com/crguezl/prdcalc
[~/javascript/PLgrado/predictiveRD/prdcalc(develop)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/predictiveRD/prdcalc
[~/javascript/PLgrado/predictiveRD/prdcalc(develop)]$ git remote -v
heroku [email protected]:predictiveparser.git (fetch)
heroku [email protected]:predictiveparser.git (push)
origin [email protected]:crguezl/prdcalc.git (fetch)
origin [email protected]:crguezl/prdcalc.git (push)
Tareas
A˜
nada:
Extienda y modifique el analizador para que acepte el lenguaje descrito por la gram´atica EBNF
del lenguaje PL/0 que se describe en la entrada de la Wikipedia Recursive descent parser. Procure que el arbol generado refleje la asociatividad correcta para las diferencias y las divisiones. No
es necesario que el lenguaje sea exactamente igual pero deber´ıa ser parecido. Tener los mismos
constructos.
Use CoffeeScript para escribir el c´odigo (fichero views/main.coffee)
Use slim para las vistas
Usa Sass para las hojas de estilo
Despliegue la aplicaci´on en Heroku
A˜
nada pruebas
79
Sinatra
V´ease el fichero main.rb.
1. Filters
2. Helpers
a) El helper css es usado en views/layout.slim
b) El helper current? es usado en views/nav.slim para a˜
nadir la clase current a la p´agina
que esta siendo visitada.
c) El estilo de la entrada de la p´agina actual es modificado en el fichero de estilo views/styles.scss
nav a.current {
background: lighten($black, 50%);
}
El m´etodo lighten es prove´ıdo por Sass .
3. Views / Templates
Sass
V´ease el fichero views/styles.scss.
1. Sass
2. Sass Basics
3. css2sass en GitHub (https://github.com/jpablobr/css2sass) y despliegue en Heroku (http://css2sass.heroku.co
Slim
V´eanse los ficheros views/*.slim:
views/layout.slim
views/home.slim
views/nav.slim
1. slim
2. Slim docs
3. html2slim
4. 2011.12.16 Tech Talk: Slim Templates de Big Nerd Ranch (Vimeo)
CoffeeScript
1. CoffeeScript
2. CoffeeScript Cookbook
3. js2coffee.org
80
´
Construyendo Arboles
con la Asociatividad Correcta
A˜
nadamos el operador - al c´odigo de
nuestra pr´actica. Para ello, podemos extender nuestro gram´atica con una regla de producci´
on:
expression → term ’+’ expression |term ’-’ expression | term
que da lugar a un c´odigo como el que sigue:
expression = ->
result = term()
if lookahead and lookahead.type is "+"
....
if lookahead and lookahead.type is "-"
match "-"
right = expression()
result =
type: "-"
left: result
right: right
Cuando le damos como entrada a = 4-2-1 produce el siguiente AST:
{
"type": "=",
"left": {
"type": "ID",
"value": "a"
},
"right": {
"type": "-",
"left": {
"type": "NUM",
"value": 4
},
"right": {
"type": "-",
"left": {
"type": "NUM",
"value": 2
},
"right": {
"type": "NUM",
"value": 1
}
}
}
}
que se corresponde con esta parentizaci´
on: a = (4 - (2 - 1))
Este ´arbol no se corresponde con la asociatividad a izquierdas del operador -. Es un ´arbol que
refleja una asociaci´
on a derechas (a = 3).
A → Aα { alpha_action }
Es
Ahora bien, el lenguaje generado por dos reglas de la forma:
A→γ
{ gamma_action }
γα∗. Por tanto el m´etodo asociado con A podr´ıa reescribirse como sigue:
81
A = () ->
gamma() # imitar gamma
gamma_action() # acci´
on sem´
antica asociada con gamma
while lookahead and lookahead.type belongs to FIRST(alpha)
alpha() # imitar alpha
alpha_action()
82
Cap´ıtulo 3
An´
alisis Sint´
actico Mediante
Precedencia de Operadores en
JavaScript
3.1.
Ejemplo Simple de Int´
erprete: Una Calculadora
1. How to write a simple interpreter in JavaScript
3.2.
An´
alisis Top Down Usando Precedencia de Operadores
1. V´ease el libro [2] Beautiful Code: Leading Programmers Explain How They Think, Cap´ıtulo 9.
2. Top Down Operator Precedence por Douglas Crockford
3. Top Down Operator Precedence demo por Douglas Crockford
4. jslint
5. David Majda - Easy parsing with PEG.js
3.2.1.
Gram´
atica de JavaScript
1. Especificaci´
on de JavaScript 1997
2. NQLL(1) grammar (Not Quite LL(1)) for JavaScrip 1997
3. Postscript con la especificaci´
on de JavaScript 1997
4. Mozilla JavaScript Language Resources
5. JavaScript 1.4 LR(1) Grammar 1999.
6. Apple JavaScript Core Specifications
7. Creating a JavaScript Parser Una implementaci´
on de ECAMScript 5.1 usando Jison disponible
en GitHub en https://github.com/cjihrig/jsparser.
83
Cap´ıtulo 4
An´
alisis Descendente mediante Parsing
Expresion Grammars en JavaScript
4.1.
Introducci´
on a los PEGs
In computer science, a parsing expression grammar, or PEG, is a type of analytic formal grammar,
i.e. it describes a formal language in terms of a set of rules for recognizing strings in the language.
The formalism was introduced by Bryan Ford in 2004 and is closely related to the family of topdown parsing languages introduced in the early 1970s.
Syntactically, PEGs also look similar to context-free grammars (CFGs), but they have a different
interpretation:
the choice operator selects the first match in PEG, while it is ambiguous in CFG.
This is closer to how string recognition tends to be done in practice, e.g. by a recursive descent
parser.
Unlike CFGs, PEGs cannot be ambiguous; if a string parses, it has exactly one valid parse tree.
It is conjectured that there exist context-free languages that cannot be parsed by a PEG, but this
is not yet proven.
4.1.1.
Syntax
Formally, a parsing expression grammar consists of:
A finite set N of nonterminal symbols.
A finite set Σ of terminal symbols that is disjoint from N .
A finite set P of parsing rules.
An expression eS termed the starting expression.
Each parsing rule in P has the form A ← e, where A is a nonterminal symbol and e is a parsing
expression.
A parsing expression is a hierarchical expression similar to a regular expression, which is constructed in the following fashion:
1. An atomic parsing expression consists of:
a) any terminal symbol,
b) any nonterminal symbol, or
c) the empty string ǫ.
84
2. Given any existing parsing expressions e, e1 , and e2 , a new parsing expression can be constructed
using the following operators:
a) Sequence: e1e2
b) Ordered choice: e1/e2
c) Zero-or-more: e∗
d ) One-or-more: e+
e) Optional: e?
f ) And-predicate: &e
g) Not-predicate: !e
4.1.2.
Semantics
The fundamental difference between context-free grammars and parsing expression grammars is
that the PEG’s choice operator is ordered:
1. If the first alternative succeeds, the second alternative is ignored.
2. Thus ordered choice is not commutative, unlike unordered choice as in context-free grammars.
3. The consequence is that if a CFG is transliterated directly to a PEG, any ambiguity in the
former is resolved by deterministically picking one parse tree from the possible parses.
4. By carefully choosing the order in which the grammar alternatives are specified, a programmer
has a great deal of control over which parse tree is selected.
5. PEGs can look ahead into the input string without actually consuming it
6. The and-predicate expression &e invokes the sub-expression e, and then succeeds if e succeeds
and fails if e fails, but in either case never consumes any input.
7. The not-predicate expression !e succeeds if e fails and fails if e succeeds, again consuming no
input in either case.
4.1.3.
Implementing parsers from parsing expression grammars
Any parsing expression grammar can be converted directly into a recursive descent parser.
Due to the unlimited lookahead capability that the grammar formalism provides, however, the
resulting parser could exhibit exponential time performance in the worst case.
It is possible to obtain better performance for any parsing expression grammar by converting
its recursive descent parser into a packrat parser, which always runs in linear time, at the cost of
substantially greater storage space requirements.
A packrat parser is a form of parser similar to a recursive descent parser in construction, except
that during the parsing process it memoizes the intermediate results of all invocations of the mutually
recursive parsing functions, ensuring that each parsing function is only invoked at most once at a given
input position.
Because of this memoization, a packrat parser has the ability to parse many context-free grammars
and any parsing expression grammar (including some that do not represent context-free languages) in
linear time.
Examples of memoized recursive descent parsers are known from at least as early as 1993.
Note that this analysis of the performance of a packrat parser assumes that enough memory
is available to hold all of the memoized results; in practice, if there were not enough memory,
some parsing functions might have to be invoked more than once at the same input position, and
consequently the parser could take more than linear time.
85
It is also possible to build LL parsers and LR parsers from parsing expression grammars, with
better worst-case performance than a recursive descent parser, but the unlimited lookahead capability
of the grammar formalism is then lost. Therefore, not all languages that can be expressed using parsing
expression grammars can be parsed by LL or LR parsers.
4.1.4.
Lexical Analysis
Parsers for languages expressed as a CFG, such as LR parsers, require a separate tokenization step
to be done first, which breaks up the input based on the location of spaces, punctuation, etc.
The tokenization is necessary because of the way these parsers use lookahead to parse CFGs that
meet certain requirements in linear time.
PEGs do not require tokenization to be a separate step, and tokenization rules can be written in
the same way as any other grammar rule.
4.1.5.
Left recursion
PEGs cannot express left-recursive rules where a rule refers to itself without moving forward in
the string. For example, the following left-recursive CFG rule:
string-of-a -> string-of-a ’a’ | ’a’
can be rewritten in a PEG using the plus operator:
string-of-a <- ’a’+
The process of rewriting indirectly left-recursive rules is complex in some packrat parsers, especially
when semantic actions are involved.
4.1.6.
Referencias y Documentaci´
on
V´ease Parsing Expression Grammar
PEG.js documentation
Testing PEG.js Online
Michael’s Blog: JavaScript Parser Generators. The PEG.js Tutorial
The Packrat Parsing and Parsing Expression Grammars Page
PL101: Create Your Own Programming Language. V´eanse [3] y [4]
PL101: Create Your Own Programming Language: Parsing
4.2.
PEGJS
What is
PEG.js is a parser generator for JavaScript that produces parsers.
PEG.js generates a parser from a Parsing Expression Grammar describing a language.
We can specify what the parser returns (using semantic actions on matched parts of the input).
Installation
To use the pegjs command, install PEG.js globally:
$ npm install -g pegjs
To use the JavaScript API, install PEG.js locally:
$ npm install pegjs
To use it from the browser, download the PEG.js library ( regular or minified version).
86
El compilador de l´ınea de comandos
[~/srcPLgrado/pegjs/examples(master)]$ pegjs --help
Usage: pegjs [options] [--] [<input_file>] [<output_file>]
Generates a parser from the PEG grammar specified in the <input_file> and writes
it to the <output_file>.
If the <output_file> is omitted, its name is generated by changing the
<input_file> extension to ".js". If both <input_file> and <output_file> are
omitted, standard input and output are used.
Options:
-e, --export-var <variable>
--cache
--allowed-start-rules <rules>
-o, --optimize <goal>
--plugin <plugin>
--extra-options <options>
--extra-options-file <file>
-v, --version
-h, --help
name of the variable where the parser
object will be stored (default:
"module.exports")
make generated parser cache results
comma-separated list of rules the generated
parser will be allowed to start parsing
from (default: the first rule in the
grammar)
select optimization for speed or size
(default: speed)
use a specified plugin (can be specified
multiple times)
additional options (in JSON format) to pass
to PEG.buildParser
file with additional options (in JSON
format) to pass to PEG.buildParser
print version information and exit
print help and exit
Using it
[~/srcPLgrado/pegjs/examples(master)]$ node
> PEG = require("pegjs")
{ VERSION: ’0.8.0’,
GrammarError: [Function],
parser:
{ SyntaxError: [Function: SyntaxError],
parse: [Function: parse] },
compiler:
{ passes:
{ check: [Object],
transform: [Object],
generate: [Object] },
compile: [Function] },
buildParser: [Function] }
> parser = PEG.buildParser("start = (’a’ / ’b’)+")
{ SyntaxError: [Function: SyntaxError],
parse: [Function: parse] }
Using the generated parser is simple — just call its parse method and pass an input string as a
parameter.
87
The method will return
a parse result or
throw an exception if the input is invalid.
You can tweak parser behavior by passing a second parameter with an options object to the parse
method.
Only one option is currently supported:
startRule which is the name of the rule to start parsing from.
> parser.parse("abba");
[ ’a’, ’b’, ’b’, ’a’ ]
>
Opciones: allowedStartRules
Specifying allowedStartRules we can set the rules the parser will
be allowed to start parsing from (default: the first rule in the grammar).
[~/srcPLgrado/pegjs/examples(master)]$ cat allowedstartrules.js
var PEG = require("pegjs");
var grammar = "a = ’hello’ b\nb = ’world’"; //"a = ’hello’ b\nb=’world’;
console.log(grammar);
var parser = PEG.buildParser(grammar,{ allowedStartRules: [’a’, ’b’] });
var r = parser.parse("helloworld", { startRule: ’a’ });
console.log(r); // [ ’hello’, ’world’ ]
r = parser.parse("helloworld")
console.log(r); // [ ’hello’, ’world’ ]
r = parser.parse("world", { startRule: ’b’ })
console.log(r); // ’world’
try {
r = parser.parse("world"); // Throws an exception
}
catch(e) {
console.log("Error!!!!");
console.log(e);
}
[~/srcPLgrado/pegjs/examples(master)]$ node allowedstartrules.js
a = ’hello’ b
b = ’world’
[ ’hello’, ’world’ ]
[ ’hello’, ’world’ ]
world
Error!!!!
{ message: ’Expected "hello" but "w" found.’,
expected: [ { type: ’literal’, value: ’hello’, description: ’"hello"’ } ],
found: ’w’,
offset: 0,
line: 1,
column: 1,
name: ’SyntaxError’ }
The exception contains
88
message
expected,
found
offset,
line,
column,
name
and properties with more details about the error.
Opciones: output
When output is set to parser, the method will return generated parser object; if set to source, it
will return parser source code as a string (default: parser).
> PEG = require("pegjs")
> grammar = "a = ’hello’ b\nb=’world’"
’a = \’hello\’ b\nb=\’world\’’
> console.log(grammar)
a = ’hello’ b
b=’world’
undefined
> parser = PEG.buildParser(grammar,{ output: "parse"})
undefined
> parser = PEG.buildParser(grammar,{ output: "source"})
> typeof parser
’string’
> console.log(parser.substring(0,100))
(function() {
/*
* Generated by PEG.js 0.8.0.
*
* http://pegjs.majda.cz/
*/
Opciones: plugin
La opci´
on plugins indica que plugin se van a usar.
[~/srcPLgrado/pegjs/examples(master)]$ cat plugin.coffee
#!/usr/bin/env coffee
PEG = require ’pegjs’
coffee = require ’pegjs-coffee-plugin’
grammar = """
a = ’hello’ _ b { console.log 1 }
b = ’world’
{ console.log 2 }
_ = [ \t]+
{ console.log 3 }
"""
parser = PEG.buildParser grammar, plugins: [coffee]
r = parser.parse "hello world"
[~/srcPLgrado/pegjs/examples(master)]$ ./plugin.coffee
3
2
1
89
cache
If true, makes the parser cache results, avoiding exponential parsing time in pathological cases
but making the parser slower (default: false).
optimize
Selects between optimizing the generated parser for parsing speed (speed) or code size (size)
(default: speed).
4.3.
Un Ejemplo Sencillo
Donde
[~/srcPLgrado/pegjs/examples(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/pegjs/examples
[~/srcPLgrado/pegjs/examples(master)]$ git remote -v
dmajda https://github.com/dmajda/pegjs.git (fetch)
dmajda https://github.com/dmajda/pegjs.git (push)
origin [email protected]:crguezl/pegjs.git (fetch)
origin [email protected]:crguezl/pegjs.git (push)
https://github.com/crguezl/pegjs/blob/master/examples/arithmetics.pegjs
arithmetics.pegjs
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ cat arithmetics.pegjs
/*
* Classic example grammar, which recognizes simple arithmetic expressions like
* "2*(3+4)". The parser generated from this grammar then computes their value.
*/
start
= additive
additive
= left:multiplicative PLUS right:additive { return left + right; }
/ left:multiplicative MINUS right:additive { return left - right; }
/ multiplicative
multiplicative
= left:primary MULT right:multiplicative { return left * right; }
/ left:primary DIV right:multiplicative { return left / right; }
/ primary
primary
= integer
/ LEFTPAR additive:additive RIGHTPAR { return additive; }
integer "integer"
= NUMBER
_ = $[ \t\n\r]*
PLUS = _"+"_
MINUS = _"-"_
90
MULT = _"*"_
DIV = _"/"_
LEFTPAR = _"("_
RIGHTPAR = _")"_
NUMBER = _ digits:$[0-9]+ _ { return parseInt(digits, 10); }
There are several types of parsing expressions, some of them containing subexpressions and thus
forming a recursive structure:
expression *
Match zero or more repetitions of the expression and return their match results in an array. The
matching is greedy, i.e. the parser tries to match the expression as many times as possible.
expression +
Match one or more repetitions of the expression and return their match results in an array. The
matching is greedy, i.e. the parser tries to match the expression as many times as possible.
$ expression
Try to match the expression. If the match succeeds, return the matched string instead of the
match result.
main.js
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ cat main.js
var PEG = require("./arithmetics.js");
var r = PEG.parse("(2+9-1)/2");
console.log(r);
Rakefile
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ cat Rakefile
PEGJS = "../bin/pegjs"
task :default => :run
desc "Compile arithmetics.pegjs"
task :compile do
sh "#{PEGJS} arithmetics.pegjs"
end
desc "Run and use the parser generated from arithmetics.pegjs"
task :run => :compile do
sh "node main.js"
end
Compilaci´
on
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ rake
../bin/pegjs arithmetics.pegjs
node main.js
5
91
4.3.1.
Asociaci´
on Incorrecta para la Resta y la Divisi´
on
∗
Definici´
on 4.3.1. Una gram´atica es recursiva por la izquierda cuando existe una derivaci´
on A =⇒
Aα.
En particular, es recursiva por la izquierda si contiene una regla de producci´
on de la forma A → Aα.
En este caso se dice que la recursi´
on por la izquierda es directa.
Cuando la gram´atica es recursiva por la izquierda, el m´etodo de an´
alisis recursivo descendente
predictivo no funciona. En ese caso, el procedimiento A asociado con A ciclar´ıa para siempre sin llegar
a consumir ning´
un terminal.
Es por eso que hemos escrito las reglas de la calculadora con recursividad a derechas,
additive
= left:multiplicative PLUS right:additive { return left + right; }
/ left:multiplicative MINUS right:additive { return left - right; }
/ multiplicative
multiplicative
= left:primary MULT right:multiplicative { return left * right; }
/ left:primary DIV right:multiplicative { return left / right; }
/ primary
pero eso da lugar a ´
arboles hundidos hacia la derecha y a una aplicaci´on de las reglas sem´
anticas
err´onea:
[~/pegjs/examples(master)]$ cat main.js
var PEG = require("./arithmetics.js");
var r = PEG.parse("5-3-2");
console.log(r);
[~/pegjs/examples(master)]$ node main.js
4
4.4.
Acciones Intermedias
Supongamos que queremos poner una acci´on sem´
antica intermedia en un programa PEG.js :
[~/srcPLgrado/pegjs/examples(master)]$ cat direct_intermedia.pegjs
a = ’a’+ { console.log("acci´
on intermedia"); } ’b’+ {
console.log("acci´
on final");
return "hello world!";
}
Al compilar nos da un mensjae de error:
[~/srcPLgrado/pegjs/examples(master)]$ pegjs direct_intermedia.pegjs
1:48: Expected "/", ";", end of input or identifier but "’" found.
La soluci´on consiste en introducir una variable sint´actica en medio que derive a la palabra vac´ıa y que
tenga asociada la correspondiente acci´on sem´
antica:
[~/srcPLgrado/pegjs/examples(master)]$ cat intermedia.pegjs
a = ’a’+ temp ’b’+ {
console.log("acci´
on final");
return "hello world!";
}
temp = { console.log("acci´
on intermedia"); }
92
Este es el progrma que usa el parser generado:
[~/srcPLgrado/pegjs/examples(master)]$ cat main_intermedia.js
var parser = require("intermedia");
var input = process.argv[2] || ’aabb’;
var result = parser.parse(input);
console.log(result);
al ejecutar tenemos:
[~/srcPLgrado/pegjs/examples(master)]$ pegjs intermedia.pegjs
[~/srcPLgrado/pegjs/examples(master)]$ node main_intermedia.js
acci´
on intermedia
acci´
on final
hello world!
4.5.
PegJS en los Browser
Donde
~/srcPLgrado/pegjs/examples(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/pegjs/examples
[~/srcPLgrado/pegjs/examples(master)]$ git remote -v
dmajda https://github.com/dmajda/pegjs.git (fetch)
dmajda https://github.com/dmajda/pegjs.git (push)
origin [email protected]:crguezl/pegjs.git (fetch)
origin [email protected]:crguezl/pegjs.git (push)
https://github.com/crguezl/pegjs/tree/master/examples
Versiones para Browser
Podemos usar directamente las versiones para los browser:
PEG.js — minified
PEG.js — development
La opci´
on -e de pegjs
[~/Dropbox/src/javascript/PLgrado/jison]$ pegjs --help
Usage: pegjs [options] [--] [<input_file>] [<output_file>]
Generates a parser from the PEG grammar specified in the <input_file> and
writes it to the <output_file>.
If the <output_file> is omitted, its name is generated by changing the
<input_file> extension to ".js". If both <input_file> and <output_file> are
omitted, standard input and output are used.
Options:
-e, --export-var <variable>
--cache
--track-line-and-column
-v, --version
-h, --help
name of the variable where the parser object
will be stored (default: "module.exports")
make generated parser cache results
make generated parser track line and column
print version information and exit
print help and exit
93
Compilaci´
on
Le indicamos que el parser se guarde en calculator:
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ rake web
../bin/pegjs -e calculator arithmetics.pegjs
[~/srcPLgrado/pegjs/examples(master)]$ head -5 arithmetics.js
calculator = (function() {
/*
* Generated by PEG.js 0.7.0.
*
* http://pegjs.majda.cz/
calc.js
Ahora, desde el JavaScript que llama al parser accedemos al objeto mediante la variable
calculator:
[~/srcPLgrado/pegjs/examples(master)]$ cat calc.js
$(document).ready(function() {
$(’#eval’).click(function() {
try {
var result = calculator.parse($(’#input’).val());
$(’#output’).html(result);
} catch (e) {
$(’#output’).html(’<div class="error"><pre>\n’ + String(e) + ’\n</pre></div>’);
}
});
$("#examples").change(function(ev) {
var f = ev.target.files[0];
var r = new FileReader();
r.onload = function(e) {
var contents = e.target.result;
input.innerHTML = contents;
}
r.readAsText(f);
});
});
arithmetic.pegjs
El PEG describe una calculadora:
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ cat arithmetics.pegjs
/*
* Classic example grammar, which recognizes simple arithmetic expressions like
* "2*(3+4)". The parser generated from this grammar then computes their value.
*/
start
= additive
additive
= left:multiplicative PLUS right:additive { return left + right; }
/ left:multiplicative MINUS right:additive { return left - right; }
/ multiplicative
94
multiplicative
= left:primary MULT right:multiplicative { return left * right; }
/ left:primary DIV right:multiplicative { return left / right; }
/ primary
primary
= integer
/ LEFTPAR additive:additive RIGHTPAR { return additive; }
integer "integer"
= NUMBER
_ = $[ \t\n\r]*
PLUS = _"+"_
MINUS = _"-"_
MULT = _"*"_
DIV = _"/"_
LEFTPAR = _"("_
RIGHTPAR = _")"_
NUMBER = _ digits:$[0-9]+ _ { return parseInt(digits, 10); }
calculator.html
[~/srcPLgrado/pegjs/examples(master)]$ cat calculator.html
<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="utf-8">
<title>pegjs</title>
<link rel="stylesheet" href="global.css" type="text/css" media="screen" charset="utf-8" />
</head>
<body>
<h1>pegjs</h1>
<div id="content">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
<script src="arithmetics.js"></script>
<script src="calc.js"></script>
<p>
Load an example:
<input type="file" id="examples" />
</p>
<p>
<table>
<tr>
<td>
<textarea id="input" autofocus cols = "40" rows = "4">2+3*4</textarea>
</td>
<td class="output">
<pre>
<span id="output"></span> <!-- Output goes here! -->
95
</pre>
</td>
<td><button id="eval" type="button">eval</button></td>
</tr>
</table>
</p>
</div>
</body>
</html>
Figura 4.1: pegjs en la web
4.6.
Eliminaci´
on de la Recursividad por la Izquierda en PEGs
Donde
[~/srcPLgrado/pegjs-coffee-plugin/examples(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/pegjs-coffee-plugin/examples
[~/srcPLgrado/pegjs-coffee-plugin/examples(master)]$ git remote -v
dignifiedquire [email protected]:Dignifiedquire/pegjs-coffee-plugin.git (fetch)
dignifiedquire [email protected]:Dignifiedquire/pegjs-coffee-plugin.git (push)
origin [email protected]:crguezl/pegjs-coffee-plugin.git (fetch)
origin [email protected]:crguezl/pegjs-coffee-plugin.git (push)
https://github.com/crguezl/pegjs-coffee-plugin/tree/master/examples
PEGjs Coffee Plugin
PEGjs Coffee Plugin is a plugin for PEG.js to use CoffeeScript in actions.
Veamos un ejemplo de uso via la API:
[~/srcPLgrado/pegjs/examples(master)]$ cat plugin.coffee
#!/usr/bin/env coffee
PEG = require ’pegjs’
coffee = require ’pegjs-coffee-plugin’
grammar = """
a = ’hello’ _ b { console.log 1; "hello world!" }
b = ’world’
{ console.log 2 }
_ = [ \t]+
{ console.log 3 }
96
"""
parser = PEG.buildParser grammar, plugins: [coffee]
r = parser.parse "hello world"
console.log(r)
[~/srcPLgrado/pegjs/examples(master)]$ coffee plugin.coffee
3
2
1
hello world!
Un Esquema de Traducci´
on Recursivo por la Izquierda
de traducci´on implementado en Jison :
Consideremos el siguiente esquema
[~/srcPLgrado/pegjs-coffee-plugin/examples(master)]$ cat leftrec.jison
/*
Exercise: Find a PEG equivalent to the following left-recursive
grammar:
*/
%lex
%%
\s+
y
.
{ /* skip whitespace */ }
{ return ’y’;}
{ return ’x’;}
/lex
%{
do_y = function(y)
{ console.log("A -> ’y’
do_y("+y+")"); return y; }
do_x = function(a, x){ console.log("A -> A ’x’ do_x("+a+", "+x+")"); return a+x; }
%}
%%
A : A ’x’ { $$ = do_x($1, $2); }
| ’y’
{ $$ = do_y($1); }
;
[~/srcPLgrado/pegjs-coffee-plugin/examples(master)]$ jison leftrec.jison
[~/srcPLgrado/pegjs-coffee-plugin/examples(master)]$ ls -ltr leftrec.j*
-rw-r--r-- 1 casiano staff
441 18 mar 20:22 leftrec.jison
-rw-r--r-- 1 casiano staff 20464 18 mar 20:34 leftrec.js
[~/srcPLgrado/pegjs-coffee-plugin/examples(master)]$ cat main_leftrec.js
var parser = require(’./leftrec’);
input = "y x x x";
var r = parser.parse(input);
[~/srcPLgrado/pegjs-coffee-plugin/examples(master)]$ node main_leftrec.js
A -> ’y’
do_y(y)
A -> A ’x’ do_x(y, x)
A -> A ’x’ do_x(yx, x)
A -> A ’x’ do_x(yxx, x)
97
M´
etodolog´ıa
Es posible modificar la gram´atica para eliminar la recursi´
on por la izquierda. En este apartado nos
limitaremos al caso de recursi´on por la izquierda directa. La generalizaci´
on al caso de recursi´on por la
izquierda no-directa se reduce a la iteraci´
on de la soluci´
on propuesta para el caso directo.
Consideremos una variable A con dos producciones:
A → Aα| β
donde α, β ∈ (V ∪ Σ)∗ no comienzan por A. Estas dos producciones pueden ser sustituidas por:
A → βα∗
eliminando as´ı la recursi´on por la izquierda.
Soluci´
on
[~/pegjs-coffee-remove-left(master)]$ cat -n remove_left_recursive.pegjs
1 /*
2
3 Exercise: Find a PEG equivalent to the following left-recursive
4 grammar:
5
6 A : A ’x’ { $$ = do_x($1, $2); } | ’y’ { $$ = do_y($1); }
7
8 */
9
10 {
11
@do_y = (y)
-> console.log("do_y(#{y})"); y
12
@do_x = (a, x)-> console.log("do_x(#{a}, #{x})"); a+x
13 }
14
15 A = y:’y’ xs:(’x’*)
16
{
17
a = @do_y(y)
18
for x in xs
19
a = @do_x(a, x)
20
a
21
}
[~/pegjs-coffee-remove-left(master)]$ pegjs --plugin pegjs-coffee-plugin remove_left_recursive.
[~/pegjs-coffee-remove-left(master)]$ ls -ltr | tail -1
-rw-rw-r-- 1 casiano staff
8919 3 jun 10:42 remove_left_recursive.js
[~/pegjs-coffee-remove-left(master)]$ cat use_remove_left.coffee
PEG = require("./remove_left_recursive.js")
inputs = [
"yxx"
"y"
"yxxx"
]
for input in inputs
console.log("input = #{input}")
r = PEG.parse input
console.log("result = #{r}\n")
98
[~/pegjs-coffee-remove-left(master)]$ coffee use_remove_left.coffee
input = yxx
do_y(y)
do_x(y, x)
do_x(yx, x)
result = yxx
input = y
do_y(y)
result = y
input = yxxx
do_y(y)
do_x(y, x)
do_x(yx, x)
do_x(yxx, x)
result = yxxx
4.7.
Eliminando la Recursividad por la Izquierda en la Calculadora
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ cat simple.pegjs
/* From the Wikipedia
Value
← [0-9]+ / ’(’ Expr ’)’
Product ← Value ((’*’ / ’/’) Value)*
Sum
← Product ((’+’ / ’-’) Product)*
Expr
← Sum
*/
{
function reduce(left, right) {
var sum = left;
// console.log("sum = "+sum);
for(var i = 0; i < right.length;i++) {
var t = right[i];
var op = t[0];
var num = t[1];
switch(op) {
case ’+’ : sum += num; break;
case ’-’ : sum -= num; break;
case ’*’ : sum *= num; break;
case ’/’ : sum /= num; break;
default : console.log("Error! "+op);
}
// console.log("sum = "+sum);
}
return sum;
}
}
sum
= left:product right:($[+-] product)* { return reduce(left, right); }
product = left:value right:($[*/] value)*
{ return reduce(left, right); }
value
= number:$[0-9]+
{ return parseInt(number,10); }
/ ’(’ sum:sum ’)’
{ return sum; }
Es posible especificar mediante llaves un c´odigo que este disponible dentro de las acciones sem´
anti99
cas.
Ejecuci´on:
[~/pegjs/examples(master)]$ cat use_simple.js
var PEG = require("./simple.js");
var r = PEG.parse("2-3-4");
console.log(r);
[~/pegjs/examples(master)]$ node use_simple.js
-5
Veamos otra ejecuci´
on:
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ cat use_simple.js
var PEG = require("./simple.js");
var r = PEG.parse("2+3*(2+1)-10/2");
console.log(r);
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ ../bin/pegjs simple.pegjs
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ node use_simple.js
6
4.8.
Eliminaci´
on de la Recursividad por la Izquierda y Atributos
Heredados
La secci´
on anterior da una forma sencilla de resolver el problema respetando la sem´
antica. Si no
se dispone de operadores de repetici´on la cosa se vuelve mas complicada. Las siguientes secciones
muestran una soluci´on para transformar un esquema de traducci´on recursivo por la izquierda en otro
no recursivo por la izquierda respetando el orden en el que se ejecutan las acciones sem´
anticas. Por
u
´ltimo se ilustra como se puede aplicar esta t´ecnica en pegjs (aunque obviamente es mucho mejor
usar la ilustrada anteriormente).
4.8.1.
Eliminaci´
on de la Recursi´
on por la Izquierda en la Gram´
atica
Es posible modificar la gram´atica para eliminar la recursi´
on por la izquierda. En este apartado nos
limitaremos al caso de recursi´on por la izquierda directa. La generalizaci´
on al caso de recursi´on por la
izquierda no-directa se reduce a la iteraci´
on de la soluci´
on propuesta para el caso directo.
Consideremos una variable A con dos producciones:
A → Aα| β
donde α, β ∈ (V ∪ Σ)∗ no comienzan por A. Estas dos producciones pueden ser sustituidas por:
A → βR
R → αR | ǫ
eliminando as´ı la recursi´on por la izquierda.
Definici´
on 4.8.1. La producci´
on R → αR se dice recursiva por la derecha.
Las producciones recursivas por la derecha dan lugar a ´arboles que se hunden hacia la derecha.
Es mas dif´ıcil traducir desde esta clase de ´arboles operadores como el menos, que son asociativos a
izquierdas.
100
Ejercicio 4.8.1. Elimine la recursi´
on por la izquierda de la gram´
atica
expr → expr − N U M
expr → N U M
4.8.2.
Eliminaci´
on de la Recursi´
on por la Izquierda en un Esquema de Traducci´
on
La eliminaci´on de la recursi´on por la izquierda es s´
olo un paso: debe ser extendida a esquemas de
traducci´on, de manera que no s´
olo se preserve el lenguaje sino la secuencia de acciones. Supongamos
que tenemos un esquema de traducci´on de la forma:
A → Aα
A → Aβ
A→γ
{ alpha_action }
{ beta_action }
{ gamma_action }
para una sentencia como γβα la secuencia de acciones ser´a:
gamma_action
beta_action alpha_action
¿C´omo construir un esquema de traducci´on para la gram´atica resultante de eliminar la recursi´on
por la izquierda que ejecute las acciones asociadas en el mismo orden?. Supongamos para simplificar,
que las acciones no dependen de atributos ni computan atributos, sino que act´
uan sobre variables
globales. En tal caso, la siguiente ubicaci´
on de las acciones da lugar a que se ejecuten en el mismo
orden:
A → γ { gamma_action } R
R → β { beta_action } R
R → α { alpha_action } R
R→ǫ
Si hay atributos en juego, la estrategia para construir un esquema de traducci´on equivalente para la
gram´atica resultante de eliminar la recursividad por la izquierda se complica. Consideremos de nuevo
el esquema de traducci´on de infijo a postfijo de expresiones aritm´eticas de restas:
expr → expr1 − N U M
expr → N U M
{ $expr{T} = $expr[1]{T}." ".$NUM{VAL}." - "}
{ $expr{T} = $NUM{VAL} }
En este caso introducimos un atributo H para los nodos de la clase r el cu´
al acumula la traducci´on
a postfijo hasta el momento. Observe como este atributo se computa en un nodo r a partir del
correspondiente atributo del el padre y/o de los hermanos del nodo:
expr → N U M { $r{H} = $NUM{VAL} } r { $expr{T} = $r{T} }
r → −N U M { $r_1{H} = $r{H}." ".$NUM{VAL}." - " } r1 { $r{T} = $r_1{T} }
r → ǫ { $r{T} = $r{H} }
El atributo H es un ejemplo de atributo heredado.
4.8.3.
Eliminaci´
on de la Recursividad por la Izquierda en PEGJS
PegJS no permite acciones intermedias. Tampoco se puede acceder al atributo de la parte izquierda.
Por eso, a la hora de implantar la soluci´on anterior debemos introducir variables sint´acticas temporales
que produzcan la palabra vac´ıa y que vayan acompa˜
nadas de la acci´on sem´
antica correspondiente.
Adem´
as nos obliga a usar variables visibles por todas las reglas sem´
anticas para emular el acceso
a los atributos de la parte izquierda de una regla de proudcci´on.
El siguiente ejemplo ilustra como eliminar la reucrusi´on por la izquierda respetando la asociatividad
de la oepraci´on de diferencia:
101
[~/pegjs/examples(master)]$ cat inherited.pegjs
{
var h = 0, number = 0;
}
e = NUMBER aux1 r
{ return h; }
aux1 = /* empty */
{ h = number; }
r =
’-’ NUMBER aux2 r
/ /* empty */
aux2 = /* empty */
{ return h; }
{ h -= number; }
NUMBER = _ digits:$[0-9]+ _
{ number = parseInt(digits, 10); return number; }
_ = $[ \t\n\r]*
[~/pegjs/examples(master)]$ cat use_inherited.js
var PEG = require("./inherited.js");
var r = PEG.parse("2-1-1");
console.log(r);
var r = PEG.parse("4-2-1");
console.log(r);
var r = PEG.parse("2-3-1");
console.log(r);
[~/pegjs/examples(master)]$ pegjs inherited.pegjs
Referenced rule "$" does not exist.
[~/pegjs/examples(master)]$ ../bin/pegjs inherited.pegjs
[~/pegjs/examples(master)]$ node use_inherited.js
0
1
-2
4.9.
Dangling else: Asociando un else con su if mas cercano
The dangling else is a problem in computer programming in which an optional else clause in an
If{then({else) statement results in nested conditionals being ambiguous.
Formally, the reference context-free grammar of the language is ambiguous, meaning there is more
than one correct parse tree.
In many programming languages one may write conditionally executed code in two forms:
the if-then form, and the if-then-else form – the else clause is optional:
if a then s
if a then s1 else s2
This gives rise to an ambiguity in interpretation when there are nested statements, specifically
whenever an if-then form appears as s1 in an if-then-else form:
if a then if b then s else s2
In this example, s is unambiguously executed when a is true and b is true, but one may interpret s2
as being executed when a is false
(thus attaching the else to the first if) or when
102
a is true and b is false (thus attaching the else to the second if).
In other words, one may see the previous statement as either of the following expressions:
if a then (if b then s) else s2
or
if a then (if b then s else s2)
This is a problem that often comes up in compiler construction, especially scannerless parsing.
The convention when dealing with the dangling else is to attach the else to the nearby if
statement.
Programming languages like Pascal and C follow this convention, so there is no ambiguity in the
semantics of the language, though the use of a parser generator may lead to ambiguous grammars.
In these cases alternative grouping is accomplished by explicit blocks, such as begin...end in Pascal
and {...} in C.
Here follows a solution in PEG.js:
danglingelse.pegjs
$ cat danglingelse.pegjs
/*
S ← ’if’ C ’then’ S ’else’ S / ’if’ C ’then’ S
*/
S =
if C:C then S1:S else S2:S { return [ ’ifthenelse’, C, S1, S2 ]; }
/ if C:C then S:S
{ return [ ’ifthen’, C, S]; }
/ O
{ return ’O’; }
_ = ’ ’*
C = _’c’_
{ return ’c’; }
O = _’o’_
{ return ’o’; }
else = _’else’_
if = _’if’_
then = _’then’_
use danglingelse.js
$ cat use_danglingelse.js
var PEG = require("./danglingelse.js");
var r = PEG.parse("if c then if c then o else o");
console.log(r);
Ejecuci´
on
$ ../bin/pegjs danglingelse.pegjs
$ node use_danglingelse.js
[ ’ifthen’, ’c’, [ ’ifthenelse’, ’c’, ’O’, ’O’ ] ]
Donde
[~/srcPLgrado/pegjs/examples(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/pegjs/examples
103
[~/srcPLgrado/pegjs/examples(master)]$ git remote -v
dmajda https://github.com/dmajda/pegjs.git (fetch)
dmajda https://github.com/dmajda/pegjs.git (push)
origin [email protected]:crguezl/pegjs.git (fetch)
origin [email protected]:crguezl/pegjs.git (push)
https://github.com/crguezl/pegjs/tree/master/examples
4.10.
Not Predicate: Comentarios Anidados
The following recursive PEG.js program matches Pascal-style nested comment syntax:
(* which can (* nest *) like this *)
Pascal comments.pegjs
$ cat pascal_comments.pegjs
/* Pascal nested comments */
P
N
=
=
C
T
=
=
Begin =
End
=
ANY
=
prog:N+
chars:$(!Begin ANY)+
/ C
Begin chars:T* End
C
/ (!Begin !End char:ANY)
’(*’
’*)’
’z’
/* any character */
/ char:[^z]
{ return prog; }
{ return chars;}
{ return chars.join(’’); }
{ return char;}
{ return ’z’; }
{ return char; }
use pascal comments.js
$ cat use_pascal_comments.js
var PEG = require("./pascal_comments.js");
var r = PEG.parse(
"not bla bla (* pascal (* nested *) comment *)"+
" pum pum (* another comment *)");
console.log(r);
Ejecuci´
on
$ ../bin/pegjs pascal_comments.pegjs
$ node use_pascal_comments.js
[ ’not bla bla ’,
’ pascal nested comment ’,
’ pum pum ’,
’ another comment ’ ]
Donde
[~/srcPLgrado/pegjs/examples(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/pegjs/examples
104
[~/srcPLgrado/pegjs/examples(master)]$ git remote -v
dmajda https://github.com/dmajda/pegjs.git (fetch)
dmajda https://github.com/dmajda/pegjs.git (push)
origin [email protected]:crguezl/pegjs.git (fetch)
origin [email protected]:crguezl/pegjs.git (push)
https://github.com/crguezl/pegjs/tree/master/examples
4.11.
Un Lenguaje Dependiente del Contexto
El lenguaje {an bn cn /n ∈ N } no puede ser expresado mediante una gram´atica independiente del
contexto.
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ cat anbncn.pegjs
/*
The following parsing expression grammar describes the classic
non-context-free language :
{ a^nb^nc^n / n >= 1 }
S ← &(A ’c’) ’a’+ B !(’a’/’b’/’c’)
A ← ’a’ A? ’b’
B ← ’b’ B? ’c’
*/
S = &(A ’c’) ’a’+ B !(’a’/’b’/’c’)
A = ’a’ A? ’b’
B = ’b’ B? ’c’
Este ejemplo puede ser obtenido desde GitHub:
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ git remote -v
dmajda https://github.com/dmajda/pegjs.git (fetch)
dmajda https://github.com/dmajda/pegjs.git (push)
origin [email protected]:crguezl/pegjs.git (fetch)
origin [email protected]:crguezl/pegjs.git (push)
Veamos un ejemplo de uso:
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ cat use_anbncn.js
var PEG = require("./anbncn.js");
var r = PEG.parse("aabbcc");
console.log(r);
try {
r = PEG.parse("aabbc");
console.log(r);
}
catch (e) {
console.log("Grr...."+e);
}
Ejecuci´on:
105
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ ../bin/pegjs anbncn.pegjs
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ node use_anbncn.js
[ ’’, [ ’a’, ’a’ ], [ ’b’, [ ’b’, ’’, ’c’ ], ’c’ ], ’’ ]
Grr....SyntaxError: Expected "c" but end of input found.
4.12.
Usando Pegjs con CoffeeScript
Instalaci´
on de pegjs-coffee-plugin
[~/Dropbox/src/javascript/PLgrado/pegjs/examples(master)]$ sudo
npm install -g pegjs-coffee-p
Ejemplo Sencillo
[~/Dropbox/src/javascript/PLgrado/pegjs-coffee-plugin/examples(master)]$ cat simple.pegjs
{
@reduce = (left, right)->
sum = left
for t in right
op = t[0]
num = t[1]
switch op
when ’+’ then sum += num; break
when ’-’ then sum -= num; break
when ’*’ then sum *= num; break
when ’/’ then sum /= num; break
else console.log("Error! "+op)
sum
}
sum
= left:product right:([+-] product)* { @reduce(left, right); }
product = left:value right:([*/] value)*
{ @reduce(left, right); }
value
= number:[0-9]+
{ parseInt(number.join(’’),10) }
/ ’(’ sum:sum ’)’
{ sum }
[~/Dropbox/src/javascript/PLgrado/pegjs-coffee-plugin/examples(master)]$
PEG = require("./simple.js")
r = PEG.parse("2+3*(2+1)-10/2")
console.log(r)
cat use_simple.coffe
[~/Dropbox/src/javascript/PLgrado/pegjs-coffee-plugin/examples(master)]$ cat Rakefile
task :default do
sh "pegcoffee simple.pegjs"
end
task :run do
sh "coffee use_simple.coffee"
end
[~/Dropbox/src/javascript/PLgrado/pegjs-coffee-plugin/examples(master)]$ rake
pegcoffee simple.pegjs
[~/Dropbox/src/javascript/PLgrado/pegjs-coffee-plugin/examples(master)]$ rake run
coffee use_simple.coffee
6
106
V´
ease Tambi´
en
pegjs-coffee-plugin en GitHub
4.13.
Pr´
actica: Analizador de PL0 Ampliado Usando PEG.js
Reescriba el analizador sint´actico del lenguaje PL0 realizado en la pr´actica 2.6 usando PEG.js .
Donde
Repositorio en GitHub
Despliegue en Heroku
[~/srcPLgrado/pegjscalc(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/pegjscalc
[~/srcPLgrado/pegjscalc(master)]$ git remote -v
heroku [email protected]:pegjspl0.git (fetch)
heroku [email protected]:pegjspl0.git (push)
origin [email protected]:crguezl/pegjscalc.git (fetch)
origin [email protected]:crguezl/pegjscalc.git (push)
Tareas
Modifique block y statement para que los procedure reciban argumentos y las llamadas a
procedimiento puedan pasar argumentos. A˜
nada if ... then ... else ....
Actualice la documentaci´
on de la gram´atica para que refleje la gram´atica ampliada
Limite el n´
umero de programas que se pueden salvar a un n´
umero prefijado, por ejemplo 10. Si
se intenta salvar uno se suprime uno al azar y se guarda el nuevo.
Las pruebas deben comprobar que la asociatividad a izquierdas funciona bien y probar todos los
constructos del lenguaje as´ı como alguna situaci´on de error
Referencias para esta Pr´
actica
V´ease el cap´ıtulo Heroku ??
Heroku Postgres
V´ease el cap´ıtulo DataMapper ??
4.14.
Pr´
actica: Ambiguedad en C++
This lab illustrates a problem that arises in C++. The C++ syntax does not disambiguate between expression statements (stmt) and declaration statements (decl). The ambiguity arises when an
expression statement has a function-style cast as its left-most subexpression. Since C does not support
function-style casts, this ambiguity does not occur in C programs. For example, the phrase
int (x) = y+z;
parses as either a decl or a stmt.
The disambiguation rule used in C++ is that if the statement can be interpreted both as a declaration and as an expression, the statement is interpreted as a declaration statement.
The following examples disambiguate into expression statements when the potential declarator is
followed by an operator different from equal or semicolon (type spec stands for a type specifier):
107
expr
dec
type_spec(i)++;
type_spec(*i)(int);
type_spec(i,3)<<d; type_spec(j)[5];
type_spec(i)->l=24; type_spec(m) = { 1, 2 };
type_spec(a);
type_spec(*b)();
type_spec(c)=23;
type_spec(d),e,f,g=0;
type_spec(h)(e,3);
Regarding to this problem, Bjarne Stroustrup remarks:
Consider analyzing a statement consisting of a sequence of tokens as follows:
type_spec (dec_or_exp) tail
Here dec_or_exp must be a declarator, an expression, or both for the statement to be legal.
This implies that tail must be a semicolon, something that can follow a parenthesized
declarator or something that can follow a parenthesized expression, that is, an initializer,
const, volatile, (, [, or a postfix or infix operator. The general cases cannot be resolved
without backtracking, nested grammars or similar advanced parsing strategies. In particular,
the lookahead needed to disambiguate this case is not limited.
The following grammar depicts an oversimplified version of the C++ ambiguity:
$ cat CplusplusNested.y
%token ID INT NUM
%right ’=’
%left ’+’
%%
prog:
/* empty */
| prog stmt
;
stmt:
expr ’;’
| decl
;
expr:
ID
| NUM
| INT ’(’ expr ’)’ /* typecast */
| expr ’+’ expr
| expr ’=’ expr
;
decl:
INT declarator ’;’
108
| INT declarator ’=’ expr ’;’
;
declarator:
ID
| ’(’ declarator ’)’
;
%%
Escriba un programa PegJS en CoffeeScript que distinga correctamente entre declaraciones y sentencias. Este es un ejemplo de un programa que usa una soluci´
on al problema:
[~/Dropbox/src/javascript/PLgrado/pegjs-coffee-plugin/examples(master)]$ cat use_cplusplus.cof
PEG = require("./cplusplus.js")
input = "int (a); int c = int (b);"
r = PEG.parse(input)
console.log("input = ’#{input}’\noutput="+JSON.stringify r)
input = "int b = 4+2 ; "
r = PEG.parse(input)
console.log("input = ’#{input}’\noutput="+JSON.stringify r)
input = "bum = caf = 4-1;\n"
r = PEG.parse(input)
console.log("input = ’#{input}’\noutput="+JSON.stringify r)
input = "b2 = int(4);"
r = PEG.parse(input)
console.log("input = ’#{input}’\noutput="+JSON.stringify r)
input = "int(4);"
r = PEG.parse(input)
console.log("input = ’#{input}’\noutput="+JSON.stringify r)
Y este un ejemplo de salida:
$ pegcoffee cplusplus.pegjs
$ coffee use_cplusplus.coffee
input = ’int (a); int c = int (b);’
output=["decl","decl"]
input = ’int b = 4+2 ; ’
output=["decl"]
input = ’bum = caf = 4-1;
’
output=["stmt"]
input = ’b2 = int(4);’
output=["stmt"]
input = ’int(4);’
output=["stmt"]
4.15.
Pr´
actica: Inventando un Lenguaje: Tortoise
El objetivo de esta pr´actica es crear un lenguaje de programaci´
on imperativa sencillo de estilo
LOGO. Para ello lea el cap´ıtulo Inventing a Language - Tortoise del curso PL101: Create Your Own Programming
109
de Nathan Whitehead. Haga todos los ejercicios e implemente el lenguaje descrito.
Puede encontrar una soluci´on a la pr´actica en GitHub en el repositorio pl101 de Dave Ingram.
Usela como gu´ıa cuando se sienta desorientado.
Recursos
Inventing a Language - Tortoise por Nathan Whitehead
Repositorio dingram / pl101 en GitHub con las soluciones a esta pr´actica.
• Blog de dingram (Dave Ingram)
Repositorio PatrixCR / PL101 en GitHub con las soluciones a esta pr´actica.
Repositorio Clinton N. Dreisbach/ PL101 en GitHub con contenidos del curso PL101
Foro
Sobre Nathan Whitehead
• Nathan’s Lessons
• Nathan Whitehead en GitHub
• Nathan in YouTube
110
Cap´ıtulo 5
An´
alisis Sint´
actico Ascendente en
JavaScript
5.1.
Conceptos B´
asicos para el An´
alisis Sint´
actico
Suponemos que el lector de esta secci´
on ha realizado con ´exito un curso en teor´ıa de aut´omatas y
lenguajes formales. Las siguientes definiciones repasan los conceptos mas importantes.
n
Definici´
on 5.1.1. Dado un conjunto A, se define A∗ el cierre de Kleene de A como: A∗ = ∪∞
n=0 A
Se admite que A0 = {ǫ}, donde ǫ denota la palabra vac´ıa, esto es la palabra que tiene longitud
cero, formada por cero s´ımbolos del conjunto base A.
Definici´
on 5.1.2. Una gram´
atica G es una cuaterna G = (Σ, V, P, S). Σ es el conjunto de terminales.
V es un conjunto (disjunto de Σ) que se denomina conjunto de variables sint´acticas o categor´ıas
gram´aticales, P es un conjunto de pares de V × (V ∪ Σ)∗ . En vez de escribir un par usando la notaci´
on
(A, α) ∈ P se escribe A → α. Un elemento de P se denomina producci´
on. Por u
´ltimo, S es un s´ımbolo
del conjunto V que se denomina s´ımbolo de arranque.
Definici´
on 5.1.3. Dada una gram´
atica G = (Σ, V, P, S) y µ = αAβ ∈ (V ∪ Σ)∗ una frase formada
por variables y terminales y A → γ una producci´
on de P , decimos que µ deriva en un paso en αγβ.
Esto es, derivar una cadena αAβ es sustituir una variable sint´
actica A de V por la parte derecha γ
de una de sus reglas de producci´
on. Se dice que µ deriva en n pasos en δ si deriva en n − 1 pasos en
∗
una cadena αAβ la cual deriva en un paso en δ. Se escribe entonces que µ =⇒ δ. Una cadena deriva
en 0 pasos en si misma.
Definici´
on 5.1.4. Dada una gram´
atica G = (Σ, V, P, S) se denota por L(G) o lenguaje generado por
G al lenguaje:
∗
L(G) = {x ∈ Σ∗ : S =⇒ x}
Esto es, el lenguaje generado por la gram´
atica G esta formado por las cadenas de terminales que
pueden ser derivados desde el s´ımbolo de arranque.
Definici´
on 5.1.5. Una derivaci´
on que comienza en el s´ımbolo de arranque y termina en una secuencia
formada por s´
olo terminales de Σ se dice completa.
∗
Una derivaci´
on µ =⇒ δ en la cual en cada paso αAx la regla de producci´
on aplicada A → γ se
aplica en la variable sint´
actica mas a la derecha se dice una derivaci´
on a derechas
∗
Una derivaci´
on µ =⇒ δ en la cual en cada paso xAα la regla de producci´
on aplicada A → γ se
aplica en la variable sint´
actica mas a la izquierda se dice una derivaci´
on a izquierdas
Definici´
on 5.1.6. Observe que una derivaci´
on puede ser representada como un a
´rbol cuyos nodos
est´
an etiquetados en V ∪ Σ. La aplicaci´
on de la regla de producci´
on A → γ se traduce en asignar como
hijos del nodo etiquetado con A a los nodos etiquetados con los s´ımbolos X1 . . . Xn que constituyen la
frase γ = X1 . . . Xn . Este ´
arbol se llama ´
arbol sint´actico concreto asociado con la derivaci´
on.
111
Definici´
on 5.1.7. Observe que, dada una frase x ∈ L(G) una derivaci´
on desde el s´ımbolo de arranque
da lugar a un ´
arbol. Ese ´
arbol tiene como ra´ız el s´ımbolo de arranque y como hojas los terminales
x1 . . . xn que forman x. Dicho ´
arbol se denomina ´arbol de an´
alisis sint´actico concreto de x. Una
derivaci´
on determina una forma de recorrido del ´
arbol de an´
alisis sint´
actico concreto.
Definici´
on 5.1.8. Una gram´
atica G se dice ambigua si existe alguna frase x ∈ L(G) con al menos
dos ´
arboles sint´
acticos. Es claro que esta definici´
on es equivalente a afirmar que existe alguna frase
x ∈ L(G) para la cual existen dos derivaciones a izquierda (derecha) distintas.
5.1.1.
Ejercicio
Dada la gram´atica con producciones:
program → declarations statements | statements
declarations → declaration ’;’ declarations | declaration ’;’
declaration → INT idlist | STRING idlist
statements → statement ’;’ statements | statement
statement → ID ’=’ expression | P expression
expression → term ’+’ expression | term
term → factor ’*’ term | factor
factor → ’(’ expression ’)’ | ID | NUM | STR
idlist → ID ’,’ idlist | ID
En esta gram´atica, Σ esta formado por los caracteres entre comillas simples y los s´ımbolos cuyos
identificadores est´an en may´
usculas. Los restantes identificadores corresponden a elementos de V . El
s´ımbolo de arranque es S = program.
Conteste a las siguientes cuestiones:
1. Describa con palabras el lenguaje generado.
2. Construya el ´
arbol de an´
alisis sint´actico concreto para cuatro frases del lenguaje.
3. Se˜
nale a que recorridos del ´
arbol corresponden las respectivas derivaciones a izquierda y a derecha
en el apartado 2.
4. ¿Es ambigua esta gram´atica?. Justifique su respuesta.
5.2.
Ejemplo Simple en Jison
Jison es un generador de analizadores sint´acticos LALR. Otro analizador LALR es JS/CC.
Gram´
atica
%%
S
A
: A
;
: /* empty */
| A x
;
basic2 lex.jison
[~/jison/examples/basic2_lex(develop)]$ cat basic2_lex.jison
/* description: Basic grammar that contains a nullable A nonterminal. */
112
%lex
%%
\s+
[a-zA-Z_]\w*
{/* skip whitespace */}
{return ’x’;}
/lex
%%
S
A
: A
{ return $1+" identifiers"; }
;
: /* empty */
{
console.log("starting");
$$ = 0;
}
| A x {
$$ = $1 + 1;
console.log($$)
}
;
index.html
$ cat basic2_lex.html
<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Jison</title>
<link rel="stylesheet" href="global.css" type="text/css" media="screen" charset="utf-8" />
</head>
<body>
<h1>basic2_lex demo</h1>
<div id="content">
<script src="jquery/jquery.js"></script>
<script src="basic2_lex.js"></script>
<script src="main.js"></script>
<p>
<input type="text" value="x x x x" /> <button>parse</button>
<span id="output"></span> <!-- Output goes here! -->
</p>
</div>
</body>
</html>
Rakefile
$ cat Rakefile
# install package:
#
sudo npm install beautifier
#
113
#
#
more about beautifier:
https://github.com/rickeyski/node-beautifier
dec "compile the grammar basic2_lex_ugly.jison"
task :default => %w{basic2_lex_ugly.js} do
sh "mv basic2_lex.js basic2_lex_ugly.js"
sh "jsbeautify basic2_lex_ugly.js > basic2_lex.js"
sh "rm -f basic2_lex_ugly.js"
end
file "basic2_lex_ugly.js" => %w{basic2_lex.jison} do
sh "jison basic2_lex.jison -o basic2_lex.js"
end
1. node-beautifier
V´
ease Tambi´
en
1. JISON
2. Try Jison Examples
3. JavaScript 1.4 LR(1) Grammar 1999.
4. Creating a JavaScript Parser Una implementaci´
on de ECMAScript 5.1 usando Jison disponible
en GitHub en https://github.com/cjihrig/jsparser. Puede probarse en: http://www.cjihrig.com/development/
5. Bison on JavaScript por Rolando Perez
6. Slogo a language written using Jison
7. List of languages that compile to JS
8. Prototype of a Scannerless, Generalized Left-to-right Rightmost (SGLR) derivation parser for JavaScript
global.css
[~/jison/examples/basic2_lex(develop)]$ cat global.css
html *
{
font-size: large;
/* The !important ensures that nothing can override what you’ve set in this style (unless i
font-family: Arial;
}
.thumb {
height: 75px;
border: 1px solid #000;
margin: 10px 5px 0 0;
}
h1
{ text-align: center; font-size: x-large; }
th, td
{ vertical-align: top; text-align: left; }
/* #finaltable * { color: white; background-color: black; }
/* #finaltable table { border-collapse:collapse; } */
114
*/
/* #finaltable table, td { border:1px solid white; } */
#finaltable:hover td { background-color: blue; }
tr:nth-child(odd)
{ background-color:#eee; }
tr:nth-child(even)
{ background-color:#00FF66; }
input
{ text-align: right; border: none;
}
textarea
{ border: outset; border-color: white;
table
{ border: inset; border-color: white; }
.hidden
{ display: none; }
.unhidden
{ display: block; }
table.center { margin-left:auto; margin-right:auto; }
#result
{ border-color: red; }
tr.error
{ background-color: red; }
pre.output
{ background-color: white; }
span.repeated { background-color: red }
span.header { background-color: blue }
span.comments { background-color: orange }
span.blanks { background-color: green }
span.nameEqualValue { background-color: cyan }
span.error { background-color: red }
body
{
background-color:#b0c4de;
}
5.2.1.
/* Align input to the right
*/
}
/* blue */
V´
ease Tambi´
en
1. JISON
2. Try Jison Examples
3. JavaScript 1.4 LR(1) Grammar 1999.
4. Creating a JavaScript Parser Una implementaci´
on de ECAMScript 5.1 usando Jison disponible
en GitHub en https://github.com/cjihrig/jsparser. Puede probarse en: http://www.cjihrig.com/development/
5. Slogo a language written using Jison
6. List of languages that compile to JS
7. Prototype of a Scannerless, Generalized Left-to-right Rightmost (SGLR) derivation parser for JavaScript
5.2.2.
Pr´
actica: Secuencia de Asignaciones Simples
Modifique este ejemplo para que el lenguaje acepte una secuencia de sentencias de asignaci´
on de
la forma ID = NUM separadas por puntos y comas, por ejemplo a = 4; b = 4.56; c = -8.57e34. El
analizador retorna un hash/objeto cuyas claves son los identificadores y cuyos valores son los n´
umeros.
Clone el repositorio en https://github.com/crguezl/jison-basic2.
Modifique los analizadores l´exico y sint´actico de forma conveniente.
A˜
nada acciones sem´
anticas para que el analizador devuelva una tabla de s´ımbolos con los identificadores y sus valores.
5.3.
Ejemplo en Jison: Calculadora Simple
1. Enlace al fork del proyecto jison de crguezl (GitHub)
115
calculator.jison
[~/jison/examples/html_calc_example(develop)]$ cat calculator.jison
/* description: Parses end executes mathematical expressions. */
/* lexical grammar */
%lex
%%
\s+
[0-9]+("."[0-9]+)?\b
"*"
"/"
"-"
"+"
"^"
"!"
"%"
"("
")"
"PI"
"E"
<<EOF>>
.
/* skip whitespace */
return ’NUMBER’
return ’*’
return ’/’
return ’-’
return ’+’
return ’^’
return ’!’
return ’%’
return ’(’
return ’)’
return ’PI’
return ’E’
return ’EOF’
return ’INVALID’
/lex
/* operator associations and precedence */
%left ’+’ ’-’
%left ’*’ ’/’
%left ’^’
%right ’!’
%right ’%’
%left UMINUS
%start expressions
%% /* language grammar */
expressions
: e EOF
{ typeof console !== ’undefined’ ? console.log($1) : print($1);
return $1; }
;
e
: e ’+’
{$$
| e ’-’
{$$
| e ’*’
{$$
e
= $1+$3;}
e
= $1-$3;}
e
= $1*$3;}
116
| e ’/’ e
{$$ = $1/$3;}
| e ’^’ e
{$$ = Math.pow($1, $3);}
| e ’!’
{{
$$ = (function fact (n) { return n==0 ? 1 : fact(n-1) * n })($1);
}}
| e ’%’
{$$ = $1/100;}
| ’-’ e %prec UMINUS
{$$ = -$2;}
| ’(’ e ’)’
{$$ = $2;}
| NUMBER
{$$ = Number(yytext);}
| E
{$$ = Math.E;}
| PI
{$$ = Math.PI;}
;
main.js
[~/jison/examples/html_calc_example(develop)]$ cat main.js
$(document).ready(function () {
$("button").click(function () {
try {
var result = calculator.parse($("input").val())
$("span").html(result);
} catch (e) {
$("span").html(String(e));
}
});
});
calculator.html
[~/jison/examples/html_calc_example(develop)]$ cat calculator.html
<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Calc</title>
<link rel="stylesheet" href="global.css" type="text/css" media="screen" charset="utf-8" />
</head>
<body>
<h1>Calculator demo</h1>
<div id="content">
<script src="jquery/jquery.js"></script>
<script src="calculator.js"></script>
<script src="main.js"></script>
<p>
<input type="text" value="PI*4^2 + 5" /> <button>equals</button>
117
<span></span> <!-- Output goes here! -->
</p>
</div>
</body>
</html>
Rakefile
[~/jisoncalc(clase)]$ cat Rakefile
task :default => %w{calcugly.js} do
sh "jsbeautify calcugly.js > calculator.js"
sh "rm -f calcugly.js"
end
file "calcugly.js" => %w{calculator.jison} do
sh "jison calculator.jison calculator.l -o calculator.js; mv calculator.js calcugly.js"
end
task :testf do
sh "open -a firefox test/test.html"
end
task :tests do
sh "open -a safari test/test.html"
end
global.css
[~/jison/examples/html_calc_example(develop)]$ cat global.css
html *
{
font-size: large;
/* The !important ensures that nothing can override what you’ve set in this style (unless i
font-family: Arial;
}
.thumb {
height: 75px;
border: 1px solid #000;
margin: 10px 5px 0 0;
}
h1
{ text-align: center; font-size: x-large; }
th, td
{ vertical-align: top; text-align: left; }
/* #finaltable * { color: white; background-color: black; }
/* #finaltable table { border-collapse:collapse; } */
/* #finaltable table, td { border:1px solid white; } */
#finaltable:hover td { background-color: blue; }
tr:nth-child(odd)
{ background-color:#eee; }
tr:nth-child(even)
{ background-color:#00FF66; }
input
{ text-align: right; border: none;
}
textarea
{ border: outset; border-color: white;
table
{ border: inset; border-color: white; }
118
*/
/* Align input to the right
}
*/
.hidden
{ display: none; }
.unhidden
{ display: block; }
table.center { margin-left:auto; margin-right:auto; }
#result
{ border-color: red; }
tr.error
{ background-color: red; }
pre.output
{ background-color: white; }
span.repeated { background-color: red }
span.header { background-color: blue }
span.comments { background-color: orange }
span.blanks { background-color: green }
span.nameEqualValue { background-color: cyan }
span.error { background-color: red }
body
{
background-color:#b0c4de;
}
/* blue */
test/assert.html
$ cat test/assert.js
var output = document.getElementById(’output’);
function assert( outcome, description) {
var li = document.createElement(’li’);
li.className = outcome ? ’pass’ : ’fail’;
li.appendChild(document.createTextNode(description));
output.appendChild(li);
};
test/test.css
~/jisoncalc(clase)]$ cat test/test.css
.pass:before {
content: ’PASS: ’;
color: blue;
font-weight: bold;
}
.fail:before {
content: ’FAIL: ’;
color: red;
font-weight: bold;
}
test/test.html
[~/jisoncalc(clase)]$ cat test/test.html
<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="UTF-8">
119
<title>Testing Our Simple Calculator</title>
<link rel="stylesheet" href="test.css" />
<script type="text/javascript" src="../calculator.js"></script>
</head>
<body>
<h1>Testing Our Simple Calculator
</h1>
<ul id="output"></ul>
<script type="text/javascript" src="______.js"></script>
<script type="text/javascript">
var r = __________.parse("a = 4*8");
assert(_______________, "a is 4*8");
assert(_____________, "32 == 4*8");
r = calculator.parse("a = 4;\nb=a+1;\nc=b*2");
assert(____________, "4 is the first computed result ");
assert(______________, "a is 4");
assert(______________, "b is 5");
assert(______________, "c is 10");
</script>
See the NetTuts+ tutorial at <a href="http://net.tutsplus.com/tutorials/javascript-ajax/q
</body>
</html>
5.3.1.
Pr´
actica: Calculadora con Listas de Expresiones y Variables
Modifique la calculadora vista en la secci´
on anterior 5.3 para que el lenguaje cumpla los siguientes
requisitos:
Extienda el lenguaje de la calculadora para que admita expresiones de asignaci´
on a = 2*3
Extienda el lenguaje de la calculadora para que admita listas de sentencias a = 2; b = a +1
El analizador devuelve la lista de expresiones evaluadas y la tabla de s´ımbolos (con las parejas
variable-valor).
Emita un mensaje de error espec´ıfico si se intentan modificar las constantes PI y e.
Emita un mensaje de error espec´ıfico si se intenta una divisi´
on por cero
Emita un mensaje de error espec´ıfico si se intenta acceder para lectura a una variable no inicializada a = c
El lenguaje deber´ıa admitir expresiones vac´ıas, estos es secuencias consecutivas de puntos y
comas sin producir error (a = 4;;; b = 5)
Introduzca pruebas unitarias como las descritas en la secci´
on ?? (Quick Tip: Quick and Easy JavaScript Test
5.4.
Conceptos B´
asicos del An´
alisis LR
Los analizadores generados por jison entran en la categor´ıa de analizadores LR. Estos analizadores
construyen una derivaci´
on a derechas inversa (o antiderivaci´
on). De ah´ı la R en LR (del ingl´es rightmost
derivation). El ´
arbol sint´actico es construido de las hojas hacia la ra´ız, siendo el u
´ltimo paso en la
antiderivaci´
on la construcci´
on de la primera derivaci´
on desde el s´ımbolo de arranque.
120
Empezaremos entonces considerando las frases que pueden aparecer en una derivaci´
on a derechas.
Tales frases consituyen el lenguaje de las formas sentenciales a rderechas F SD:
Definici´
on 5.4.1. Dada una gram´
atica G = (Σ, V, P, S) no ambigua, se denota por F SD (lenguaje
de las formas Sentenciales a Derechas) al lenguaje de las sentencias que aparecen en una derivaci´
on
a derechas desde el s´ımbolo de arranque.


∗


F SD = α ∈ (Σ ∪ V )∗ : ∃S =⇒ α


RM
Donde la notacion RM indica una derivaci´
on a derechas ( rightmost). Los elementos de F SD se
llaman “formas sentenciales derechas”.
Dada una gram´atica no ambigua G = (Σ, V, P, S) y una frase x ∈ L(G) el proceso de antiderivaci´
on
consiste en encontrar la u
´ltima derivaci´
on a derechas que di´
o lugar a x. Esto es, si x ∈ L(G) es porque
existe una derivaci´
on a derechas de la forma
∗
S =⇒ yAz =⇒ ywz = x.
El problema es averiguar que regla A → w se aplic´o y en que lugar de la cadena x se aplic´o. En
general, si queremos antiderivar una forma sentencial derecha βαw debemos averiguar por que regla
A → α seguir y en que lugar de la forma (despu´es de β en el ejemplo) aplicarla.
∗
S =⇒ βAw =⇒ βαw.
La pareja formada por la regla y la posici´on se denomina handle, mango o manecilla de la forma.
Esta denominaci´on viene de la visualizaci´
on gr´
afica de la regla de producci´
on como una mano que
nos permite escalar hacia arriba en el ´
arbol. Los “dedos” ser´ıan los s´ımbolos en la parte derecha de la
regla de producci´
on.
Definici´
on 5.4.2. Dada una gram´
atica G = (Σ, V, P, S) no ambigua, y dada una forma sentencial
∗
derecha α = βγx, con x ∈ Σ , el mango o handle de α es la u
´ltima producci´
on/posici´
on que di´
o lugar
a α:
∗
S =⇒ βBx =⇒ βγx = α
RM
Escribiremos: handle(α) = (B → γ, βγ). La funci´on handle tiene dos componentes: handle1 (α) =
B → γ y handle2 (α) = βγ
Si dispusieramos de un procedimiento que fuera capaz de identificar el mango, esto es, de detectar
la regla y el lugar en el que se posiciona, tendr´ıamos un mecanismo para construir un analizador.
Lo curioso es que, a menudo es posible encontrar un aut´omata finito que reconoce el lenguaje de los
prefijos βγ que terminan en el mango. Con mas precisi´
on, del lenguaje:
Definici´
on 5.4.3. El conjunto de prefijos viables de una gram´
atica G se define como el conjunto:


∗


P V = δ ∈ (Σ ∪ V )∗ : ∃S =⇒ α = βγx y δ es un pref ijo de handle2 (α) = βγ


RM
Esto es, es el lenguaje de los prefijos viables es el conjunto de frases que son prefijos de handle2 (α)) =
βγ, siendo α una forma sentencial derecha (α ∈ F SD). Los elementos de P V se denominan prefijos
viables.
Obs´ervese que si se dispone de un aut´
omata que reconoce P V entonces se dispone de un mecanismo
para investigar el lugar y el aspecto que pueda tener el mango. Si damos como entrada la sentencia
α = βγx a dicho aut´
omata, el aut´
omata aceptar´
a la cadena βγ pero rechazar´a cualquier extensi´
on del
prefijo. Ahora sabemos que el mango ser´a alguna regla de producci´
on de G cuya parte derecha sea un
sufijo de βγ.
121
Definici´
on 5.4.4. El siguiente aut´
omata finito no determinista puede ser utilizado para reconocer el
lenguaje de los prefijos viables PV:
Alfabeto = V ∪ Σ
Los estados del aut´
omata se denominan LR(0) items. Son parejas formadas por una regla de
producci´
on de la gram´
atica y una posici´
on en la parte derecha de la regla de producci´
on. Por
ejemplo, (E → E + E, 2) ser´ıa un LR(0) item para la gram´
atica de las expresiones.
Conjunto de Estados:
Q = {(A → α, n) : A → α ∈ P, n ≤ |α|}
La notaci´
on | α | denota la longitud de la cadena | α |. En vez de la notaci´
on (A → α, n)
escribiremos: A → β↑ γ = α, donde la flecha ocupa el lugar indicado por el n´
umero n =| β | :
La funci´
on de transici´
on intenta conjeturar que partes derechas de reglas de producci´
on son viables. El conjunto de estados actual del NFA representa el conjunto de pares (regla de producci´
on,
posici´
on en la parte derecha) que tienen alguna posibilidad de ser aplicadas de acuerdo con la
entrada procesada hasta el momento:
δ(A → α↑ Xβ, X) = A → αX↑ β ∀X ∈ V ∪ Σ
δ(A → α↑ Bβ, ǫ) = B →↑ γ ∀B → γ ∈ P
Estado de arranque: Se a˜
nade la “superregla” S ′ → S a la gram´
atica G = (Σ, V, P, S). El LR(0)
′
item S →↑ S es el estado de arranque.
Todos los estados definidos (salvo el de muerte) son de aceptaci´
on.
Denotaremos por LR(0) a este aut´
omata. Sus estados se denominan LR(0) − items. La idea es
que este aut´omata nos ayuda a reconocer los prefijos viables P V .
Una vez que se tiene un aut´
omata que reconoce los prefijos viables es posible construir un analizador sint´actico que construye una antiderivaci´
on a derechas. La estrategia consiste en “alimentar”
el aut´omata con la forma sentencial derecha. El lugar en el que el aut´omata se detiene, rechazando
indica el lugar exacto en el que termina el handle de dicha forma.
Ejemplo 5.4.1. Consideremos la gram´
atica:
S→aSb
S→ǫ
El lenguaje generado por esta gram´
atica es L(G) = {an bn : n ≥ 0} Es bien sabido que el lenguaje
L(G) no es regular. La figura 5.1 muestra el aut´omata finito no determinista con ǫ-transiciones (NFA)
que reconoce los prefijos viables de esta gram´
atica, construido de acuerdo con el algoritmo 5.4.4.
V´ease https://github.com/crguezl/jison-aSb para una implementaci´
on en Jison de una variante de
esta gram´
atica.
Ejercicio 5.4.1. Simule el comportamiento del aut´
omata sobre la entrada aabb. ¿Donde rechaza? ¿En
que estados est´
a el aut´
omata en el momento del rechazo?. ¿Qu´e etiquetas tienen? Haga tambi´en las
trazas del aut´
omata para las entradas aaSbb y aSb. ¿Que antiderivaci´
on ha construido el aut´
omata con
sus sucesivos rechazos? ¿Que terminales se puede esperar que hayan en la entrada cuando se produce
el rechazo del aut´
omata?
122
Figura 5.1: NFA que reconoce los prefijos viables
5.5.
5.5.1.
Construcci´
on de las Tablas para el An´
alisis SLR
Los conjuntos de Primeros y Siguientes
Repasemos las nociones de conjuntos de Primeros y siguientes:
Definici´
on 5.5.1. Dada una gram´
atica G = (Σ, V, P, S) y una frase α ∈ (V ∪Σ)∗ se define el conjunto
F IRST (α) como:n
o
∗
F IRST (α) = b ∈ Σ : α =⇒ bβ ∪ N (α)
donde:
∗
{ǫ} si α =⇒ ǫ
N (α) =
∅
en otro caso
Definici´
on 5.5.2. Dada una gram´
atica G = (Σ, V, P, S) y una variable A ∈ V se define el conjunto
F OLLOW (A) como:n
o
∗
F OLLOW (A) = b ∈ Σ : ∃ S =⇒ αAbβ ∪ E(A)
donde
∗
{$} si S =⇒ αA
E(A) =
∅
en otro caso
Algoritmo 5.5.1. Construcci´
on de los conjuntos F IRST (X)
1. Si X ∈ Σ entonces F IRST (X) = X
2. Si X → ǫ entonces F IRST (X) = F IRST (X) ∪ {ǫ}
3. Si X ∈ V y X → Y1 Y2 · · · Yk ∈ P entonces
i = 1;
do
F IRST (X) = F IRST (X) ∪ F IRST (Yi ) − {ǫ};
i + +;
mientras (ǫ ∈ F IRST (Yi ) and (i ≤ k))
si (ǫ ∈ F IRST (Yk ) and i > k) F IRST (X) = F IRST (X) ∪ {ǫ}
Este algoritmo puede ser extendido para calcular F IRST (α) para α = X1 X2 · · · Xn ∈ (V ∪ Σ)∗ .
123
Algoritmo 5.5.2. Construcci´
on del conjunto F IRST (α)
i = 1;
F IRST (α) = ∅;
do
F IRST (α) = F IRST (α) ∪ F IRST (Xi ) − {ǫ};
i + +;
mientras (ǫ ∈ F IRST (Xi ) and (i ≤ n))
si (ǫ ∈ F IRST (Xn ) and i > n) F IRST (α) = F IRST (X) ∪ {ǫ}
Algoritmo 5.5.3. Construcci´
on de los conjuntos F OLLOW (A) para las variables sint´
acticas A ∈ V :
Repetir los siguientes pasos hasta que ninguno de los conjuntos F OLLOW cambie:
1. F OLLOW (S) = {$} ($ representa el final de la entrada)
2. Si A → αBβ entonces
F OLLOW (B) = F OLLOW (B) ∪ (F IRST (β) − {ǫ})
3. Si A → αB o bien A → αBβ y ǫ ∈ F IRST (β) entonces
F OLLOW (B) = F OLLOW (B) ∪ F OLLOW (A)
5.5.2.
Construcci´
on de las Tablas
Para la construcci´
on de las tablas de un analizador SLR se construye el aut´
omata finito determinista
(DFA) (Q, Σ, δ, q0 ) equivalente al NFA presentado en la secci´
on 5.4 usando el algoritmo de construcci´
on
del subconjunto.
Como recordar´a, en la construcci´
on del subconjunto, partiendo del estado de arranque q0 del NFA
con ǫ-transiciones se calcula su clausura {q0 } y las clausuras de los conjuntos de estados δ({q0 }, a) a
los que transita. Se repite el proceso con los conjuntos resultantes hasta que no se introducen nuevos
conjuntos-estado.
La clausura A de un subconjunto de estados del aut´omata A esta formada por todos los estados
que pueden ser alcanzados mediante transiciones etiquetadas con la palabra vac´ıa (denominadas ǫ
transiciones) desde los estados de A. Se incluyen en A, naturalmente los estados de A.
ˆ ′ , ǫ) = q}
A = {q ∈ Q / ∃q ′ ∈ Q : δ(q
Aqu´ı δˆ denota la funci´
on de transici´
on del aut´
omata extendida a cadenas de Σ∗ .
ˆ
ˆ x) = δ(δ(q, y), a) si x = ya
δ(q,
q
si x = ǫ
(5.1)
En la pr´actica, y a partir de ahora as´ı lo haremos, se prescinde de diferenciar entre δ y δˆ us´andose
indistintamente la notaci´
on δ para ambas funciones.
La clausura puede ser computada usando una estructura de pila o aplicando la expresi´
on recursiva
dada en la ecuaci´
on 5.1.
Para el NFA mostrado en el ejemplo 5.4.1 el DFA constru´ıdo mediante esta t´ecnica es el que se
muestra en la figura 5.3. Se ha utilizado el s´ımbolo # como marcador. Se ha omitido el n´
umero 3 para
que los estados coincidan en numeraci´
on con los generados por jison (v´ease el cuadro ??).
124
Figura 5.2: DFA equivalente al NFA de la figura 5.1
Un analizador sint´actico LR utiliza una tabla para su an´
alisis. Esa tabla se construye a partir de la
tabla de transiciones del DFA. De hecho, la tabla se divide en dos tablas, una llamada tabla de saltos
o tabla de gotos y la otra tabla de acciones.
La tabla goto de un analizador SLR no es m´
as que la tabla de transiciones del aut´omata DFA
obtenido aplicando la construcci´
on del subconjunto al NFA definido en 5.4.4. De hecho es la tabla
de transiciones restringida a V (recuerde que el alfabeto del aut´omata es V ∪ Σ, i denota al i-´esimo
estado resultante de aplicar la construcci´
on del subconjunto y que Ii denota al conjunto de LR(0) item
asociado con dicho estado):
δ|V ×Q : V × Q → Q.
donde se define goto(i, A) = δ(A, Ii )
La parte de la funci´on de transiciones del DFA que corresponde a los terminales que no producen
rechazo, esto es, δ|Σ×Q : Σ × Q → Q se adjunta a una tabla que se denomina tabla de acciones. La
tabla de acciones es una tabla de doble entrada en los estados y en los s´ımbolos de Σ. Las acciones de
transici´on ante terminales se denominan acciones de desplazamiento o (acciones shift):
δ|Σ×Q : Σ × Q → Q
donde se define action(i, a) = shif t δ(a, Ii )
Cuando un estado s contiene un LR(0)-item de la forma A → α↑ , esto es, el estado corresponde
a un posible rechazo, ello indica que hemos llegado a un final del prefijo viable, que hemos visto α y
que, por tanto, es probable que A → α sea el handle de la forma sentencial derecha actual. Por tanto,
a˜
nadiremos en entradas de la forma (s, a) de la tabla de acciones una acci´on que indique que hemos
encontrado el mango en la posici´on actual y que la regla asociada es A → α. A una acci´on de este tipo
se la denomina acci´
on de reducci´
on.
La cuesti´
on es, ¿para que valores de a ∈ Σ debemos disponer que la acci´on para (s, a) es de
reducci´on?
Se define action(i, a) = reduce A → α ¿Pero, para que a ∈ Σ?
125
Podr´ıamos decidir que ante cualquier terminal a ∈ Σ que produzca un rechazo del aut´omata, pero
podemos ser un poco mas selectivos. No cualquier terminal puede estar en la entrada en el momento
en el que se produce la antiderivaci´
on o reducci´on. Observemos que si A → α es el handle de γ es
porque:
∗
∗
∃S =⇒ βAbx =⇒ βαbx = γ
RM
RM
Por tanto, cuando estamos reduciendo por A → α los u
´nicos terminales legales que cabe esperar
en una reducci´on por A → α son los terminales b ∈ F OLLOW (A).
Se define action(i, b) = reduce A → α Para b ∈ F OLLOW (A)
Dada una gram´atica G = (Σ, V, P, S), podemos construir las tablas de acciones (action table) y
transiciones (gotos table) mediante el siguiente algoritmo:
Algoritmo 5.5.4. Construcci´
on de Tablas SLR
1. Utilizando el Algoritmo de Construcci´
on del Subconjunto, se construye el Aut´
omata Finito Determinista (DFA) (Q, V ∪ Σ, δ, I0 , F ) equivalente al Aut´
omata Finito No Determinista (NFA)
definido en 5.4.4. Sea C = {I1 , I2 , · · · In } el conjunto de estados del DFA. Cada estado Ii es un
conjunto de LR(0)-items o estados del NFA. Asociemos un ´ındice i con cada conjunto Ii .
2. La tabla de gotos no es m´
as que la funci´
on de transici´
on del aut´
omata restringida a las variables
de la gram´
atica:
goto(i, A) = δ(Ii , A) para todo A ∈ V
3. Las acciones para el estado Ii se determinan como sigue:
a) Si A → α↑ aβ ∈ Ii , δ(Ii , a) = Ij , a ∈ Σ entonces:
action[i][a] = shif t j
b) Si S ′ → S↑ ∈ Ii entonces
action[i][$] = accept
c) Para cualquier otro caso de la forma A → α↑ ∈ Ii distinto del anterior hacer
∀a ∈ F OLLOW (A) : action[i][a] = reduce A → α
4. Las entradas de la tabla de acci´
on que queden indefinidas despu´es de aplicado el proceso anterior
corresponden a acciones de “error”.
Definici´
on 5.5.3. Si alguna de las entradas de la tabla resulta multievaluada, decimos que existe un
conflicto y que la gram´
atica no es SLR.
1. En tal caso, si una de las acciones es de ‘reducci´
on” y la otra es de ‘desplazamiento”, decimos
que hay un conflicto shift-reduce o conflicto de desplazamiento-reducci´
on.
2. Si las dos reglas indican una acci´
on de reducci´
on, decimos que tenemos un conflicto reduce-reduce
o de reducci´
on-reducci´
on.
Ejemplo 5.5.1. Al aplicar el algoritmo 5.5.4 a la gram´
atica 5.4.1
126
1
2
S→aSb
S→ǫ
partiendo del aut´
omata finito determinista que se construy´
o en la figura 5.3 y calculando los conjuntos de primeros y siguientes
FIRST
a, ǫ
S
FOLLOW
b, $
obtenemos la siguiente tabla de acciones SLR:
0
1
2
4
5
a
s2
b
r2
s2
r2
s5
r1
$
r2
aceptar
r2
r1
Las entradas denotadas con s n (s por shift) indican un desplazamiento al estado n, las denotadas
con r n (r por reduce o reducci´
on) indican una operaci´
on de reducci´
on o antiderivaci´
on por la regla
n. Las entradas vac´ıas corresponden a acciones de error.
El m´etodo de an´
alisis LALR usado por jison es una extensi´
on del m´etodo SLR esbozado aqui.
Supone un compromiso entre potencia (conjunto de gram´aticas englobadas) y eficiencia (cantidad de
memoria utilizada, tiempo de proceso). Veamos como jison aplica la construcci´
on del subconjunto a
la gram´atica del ejemplo 5.4.1. Para ello construimos el siguiente programa jison:
[~/srcPLgrado/aSb(develop)]$ cat -n aSb.jison
1 %lex
2 %%
3 .
{ return yytext; }
4 /lex
5 %%
6 P: S
{ return $1; }
7 ;
8 S: /* empty */ { console.log("empty");
$$ = ’’; }
9
| ’a’ S ’b’ { console.log("S -> aSb"); $$ = $1+$2+$3; }
10 ;
11 %%
y lo compilamos con jison. Estas son las opciones disponibles:
nereida:[~/PLgradoBOOK(eps)]$ jison --help
Usage: jison [file] [lexfile] [options]
file
lexfile
file containing a grammar
file containing a lexical grammar
Options:
-o FILE, --outfile FILE
-t, --debug
-t TYPE, --module-type TYPE
-V, --version
Filename and base module name of the generated parser
Debug mode
The type of module to generate (commonjs, amd, js)
print version and exit
Desafortunadamente carece de la t´ıpica opci´
on -v que permite generar las tablas de an´
alisis. Podemos
intentar usar bison, pero, obviamente, bison protesta ante la entrada:
127
[~/srcPLgrado/aSb(develop)]$ bison -v aSb.jison
aSb.jison:1.1-4: invalid directive: ‘%lex’
aSb.jison:3.1: syntax error, unexpected identifier
aSb.jison:4.1: invalid character: ‘/’
El error es causado por la presencia del analizador l´exico empotrado en el fichero aSb.jison. Si
suprimimos provisionalmente las l´ıneas del analizador l´exico empotrado, bison es capaz de analizar
la gram´atica:
[~/srcPLgrado/aSb(develop)]$ bison -v aSb.jison
[~/srcPLgrado/aSb(develop)]$ ls -ltr | tail -1
-rw-rw-r-- 1 casiano staff
926 19 mar 13:29 aSb.output
Que tiene los siguientes contenidos:
[~/srcPLgrado/aSb(develop)]$ cat -n aSb.output
1 Grammar
2
3
0 $accept: P $end
4
5
1 P: S
6
7
2 S: /* empty */
8
3 | ’a’ S ’b’
9
10
11 Terminals, with rules where they appear
12
13 $end (0) 0
14 ’a’ (97) 3
15 ’b’ (98) 3
16 error (256)
17
18
19 Nonterminals, with rules where they appear
20
21 $accept (5)
22
on left: 0
23 P (6)
24
on left: 1, on right: 0
25 S (7)
26
on left: 2 3, on right: 1 3
27
28
29 state 0
30
31
0 $accept: . P $end
32
33
’a’ shift, and go to state 1
34
35
$default reduce using rule 2 (S)
36
37
P go to state 2
38
S go to state 3
39
128
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
state 1
3 S: ’a’ . S ’b’
’a’
shift, and go to state 1
$default
S
reduce using rule 2 (S)
go to state 4
state 2
0 $accept: P . $end
$end
shift, and go to state 5
state 3
1 P: S .
$default
reduce using rule 1 (P)
state 4
3 S: ’a’ S . ’b’
’b’
shift, and go to state 6
state 5
0 $accept: P $end .
$default
accept
state 6
3 S: ’a’ S ’b’ .
$default
reduce using rule 3 (S)
Observe que el final de la entrada se denota por $end y el marcador en un LR-item por un punto.
F´ıjese en el estado 1: En ese estado est´an tambi´en los items
S -> . ’a’ S ’b’ y S -> .
sin embargo no se explicitan por que se entiende que su pertenencia es consecuencia directa de
aplicar la operaci´on de clausura. Los LR items cuyo marcador no est´a al principio se denominan items
n´
ucleo.
129
5.6.
Pr´
actica: Analizador de PL0 Usando Jison
Reescriba el analizador sint´actico del lenguaje PL0 realizado en las pr´acticas 2.6 y 4.13 usando
Jison .
Donde
Repositorio en GitHub
Despliegue en Heroku
[~/jison/jisoncalc(develop)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/jison/jisoncalc
[~/jison/jisoncalc(develop)]$ git remote -v
heroku [email protected]:jisoncalc.git (fetch)
heroku [email protected]:jisoncalc.git (push)
origin [email protected]:crguezl/ull-etsii-grado-pl-jisoncalc.git (fetch)
origin [email protected]:crguezl/ull-etsii-grado-pl-jisoncalc.git (push)
Tareas
La salida debe ser el AST del programa de entrada
Modifique block y statement para que los procedure reciban argumentos y las llamadas a
procedimiento puedan pasar argumentos.
A˜
nada if ... then ... else ....
Actualice la documentaci´
on de la gram´atica para que refleje la gram´atica ampliada
Limite el n´
umero de programas que se pueden salvar a un n´
umero prefijado, por ejemplo 10. Si
se intenta salvar uno se suprime uno al azar y se guarda el nuevo.
Las pruebas deben comprobar que los AST generados reflejan la sem´antica del lenguaje as´ı como
alguna situaci´on de error
S´olo usuarios autenticados pueden salvar sus programas en la base de datos.
Extienda la autenticaci´
on OAuth para que adem´
as de Google pueda hacerse con Twitter
´o GitHub ´
o Facebook ´
o ... S´olo debe implementar una.
M´etodo de Entrega:
• Use un repositorio privado en BitBucket o bien solicite al administrador del Centro de
C´alculo un repositorio privado en GitHub.
• Comparta dicho repositorio con sus colaboradores y con el profesor.
• Suba la pr´actica al workshop/taller antes de la fecha l´ımite
• Cuando el taller pase a la fase de evaluaci´on haga p´
ublico su repositorio
Referencias para esta Pr´
actica
V´ease el cap´ıtulo Oauth: Google, Twitter, GitHub, Facebook ??
V´ease Intridea Omniauth y omniauth en GitHub
La gema omniauth-google-oauth2
Google Developers Console
130
Revoking Access to an App in Google
La gema sinatra-flash
V´ease el cap´ıtulo Heroku ??
Heroku Postgres
V´ease el cap´ıtulo DataMapper ??
5.7.
´
Pr´
actica: An´
alisis de Ambito
en PL0
Objetivos
Modifique la pr´actica anterior para que cada nodo del tipo PROCEDURE disponga de una tabla de
s´ımbolos en la que se almacenan todos las constantes, variables y procedimientos declarados en
el mismo.
Existir´a ademas una tabla de s´ımbolos asociada con el nodo ra´ız que representa al programa
principal.
Las declaraciones de constantes y variables no crean nodo, sino que se incorporan como informaci´on a la tabla de s´ımbolos del procedimiento actual
Para una entrada de la tabla de s´ımbolos sym["a"] se guarda que clase de objeto es: constante,
variable, procedimiento, etc.
Si es un procedimiento se guarda el n´
umero de argumentos
Si es una constante se guarda su valor
Cada uso de un identificador (constante, variable, procedimiento) tiene un atributo declared_in
que referencia en que nodo se declar´o
Si un identificador es usado y no fu´e declarado es un error
Si se trata de una llamada a procedimiento (se ha usado CALL y el identificador corresponde a un
PROCEDURE) se comprobar´a que el n´
umero de argumentos coincide con el n´
umero de par´
ametros
declarados en su definici´on
Si es un identificador de una constante, es un error que sea usado en la parte izquierda de una
asignaci´
on (que no sea la de su declaraci´
on)
Base de Datos
1. Guarde en una tabla el nombre de usuario que guard´
o un programa. Provea una ruta para
ver los programas de un usuario.
2. Un programa belongs_to un usuario. Un usuario has n programas. Vea la secci´
on DataMapper Associat
Use la secci´
on issues de su repositorio en GitHub para coordinarse as´ı como para llevar un
hist´
orico de las incidencias y la forma en la que se resolvieron. Repase el tutorial Mastering Issues
131
5.8.
Pr´
actica: Traducci´
on de Infijo a Postfijo
Modifique el programa Jison realizado en la pr´actica 5.3.1 para traducir de infijo a postfijo. A˜
nada
los operadores de comparaci´on e igualdad. Por ejemplo
Infijo
a = 3+2*4
b = a == 11
Postfijo
3 2 4 * + &a =
a 11 == &b =
En estas traducciones la notaci´
on &a indica la direcci´on de la variable a y a indica el valor almacenado
en la variable a.
A˜
nada sentencias if ... then e if ... then ... else
Para realizar la traducci´on de estas sentencias a˜
nada instrucciones jmp label y jmpz label (por
jump if zero) y etiquetas:
Infijo
Postfijo
2
5
+
3
*
&a
=
a
0
==
jmpz else1
5
&b
=
jmp endif0
a = (2+5)*3;
if a == 0 then b = 5 else b = 3;
c = b + 1;
:else1
3
&b
=
:endif0
b
1
+
&c
=
Parta del repositorio https://github.com/crguezl/jison-simple-html-calc.
5.9.
Pr´
actica: Calculadora con Funciones
A˜
nada funciones y sentencias de llamada a funci´on a la pr´actica de traducci´on de infijo a postfijo
5.8. Sigue un ejemplo de traducci´on:
132
def f(x) { x + 1 }
def g(a, b) { a * f(b) }
c = 3;
f(1+c);
g(3, 4)
:f
args :x
$x
1
+
return
args :a,:b
$a
$b
call :f
*
return
:g
:main:
3
&c
=
1
c
+
call :f
3
4
call :g
Las funciones retornan la u
´ltima expresi´
on evaluada
Es un error llamar a una funci´on con un n´
umero de argumentos distinto que el n´
umero de
par´
ametros con el que fu´e declarada
En la llamada, los argumentos se empujan en la pila. Despu´es la instrucci´on call :etiqueta
llama a la funci´on con el nombre dado por la etiqueta
Dentro de la funci´on los argumentos se sit´
uan por encima del puntero base. La pseudo-instrucci´on
args, p1, p2, ... da nombre a los par´
ametros empujados. Dentro del cuerpo de la funci´on
nos referimos a ellos prefij´
andolos con $.
La instrucci´on return limpia la pila dej´
andola en su estado anterior y retorna la u
´ltima expresi´
on
evaluada
5.10.
´
Pr´
actica: Calculadora con An´
alisis de Ambito
Extienda la pr´actica anterior para que haga un an´
alisis completo del ´ambito de las variables.
A˜
nada declaraciones de variable con var x, y = 1, z. Las variables podr´an opcionalmente ser
inicializadas. Se considerar´
a un error usar una variable no declarada.
Modifique la gram´atica para que permita el anidamiento de funciones: funciones dentro de funciones.
var c = 4, d = 1, e;
def g(a, b) {
var d, e;
def f(u, v) { a + u + v + d }
a * f(b, 2) + d + c
}
133
Una declaraci´
on de variable en un ´
ambito anidado tapa a una declaraci´on con el mismo nombre
en el ´ambito exterior.
var c = 4, d = 1, e;
# global:
var c,d,e
def g(a, b) {
:g.f
var d, e; # esta "d" tapa la d anterior
$a, 1
def f(u, v) { a + u + v + d }
$u, 0
a * f(b, 2) + d + c
+
}
$v, 0
+
d, 1
+
return
:g
$a, 0
$b, 0
2
call :g.f
*
d, 0
# acceder a la d en el ´
ambito actual
+
c, 1
+
return
Los nombres de funciones se traducen por una secuencia anidada de nombres que indican su
´ambito. As´ı la funci´on f anidada en g es traducida a la funci´on con nombre g.f. Una funci´on h
anidada en una funci´on f anidada en g es traducida a la funci´on con nombre g.f.h
Las variables ademas de su nombre (direcci´
on/offset) reciben un entero adicional 0,1,2, . . . que
indica su nivel de anidamiento. El n´
umero de stack frames que hay que recorrer para llegar a la
variable
$a, 1
$u, 0
+
$v, 0
+
d, 1
+
Asi $a, 1 significa acceder al par´
ametro a que est´a a distancia 1 del stack frame/´
ambito actual
y $v, 0 es el par´
ametro v en el ´
ambito/stack frame actual
El frame pointer o base pointer BP indica el nivel de anidamiento est´atico (en el fuente) de la
rutina. As´ı cuando se va a buscar una variable local declarada en la rutina que anida la actual
se recorre la lista de frames via BP o frame pointer tantas veces como el nivel de anidamiento
indique.
1. Esto es lo que dice la Wikipedia sobre la implementaci´
on de llamadas a subrutinas anidadas:
Programming languages that support nested subroutines also have a field in the call
frame that points to the stack frame of the latest activation of the procedure that
most closely encapsulates the callee, i.e. the immediate scope of the callee. This is
134
called an access link or static link (as it keeps track of static nesting during dynamic
and recursive calls) and provides the routine (as well as any other routines it may
invoke) access to the local data of its encapsulating routines at every nesting level.
2. Esto es lo que dice sobre las ventajas de tener una pila y de almacenar la direcci´on de
retorno y las variables locales:
When a subroutine is called, the location (address) of the instruction at which it
can later resume needs to be saved somewhere. Using a stack to save the return
address has important advantages over alternatives. One is that each task has
its own stack, and thus the subroutine can be reentrant, that is, can be active
simultaneously for different tasks doing different things. Another benefit is that
recursion is automatically supported. When a function calls itself recursively, a
return address needs to be stored for each activation of the function so that it can
later be used to return from the function activation. This capability is automatic
with a stack.
3. Almacenamiento local:
A subroutine frequently needs memory space for storing the values of local variables, the variables that are known only within the active subroutine and do not
retain values after it returns. It is often convenient to allocate space for this use by
simply moving the top of the stack by enough to provide the space. This is very fast
compared to heap allocation. Note that each separate activation of a subroutine
gets its own separate space in the stack for locals.
4. Par´
ametros:
Subroutines often require that values for parameters be supplied to them by the
code which calls them, and it is not uncommon that space for these parameters
may be laid out in the call stack.
The call stack works well as a place for these parameters, especially since each
call to a subroutine, which will have differing values for parameters, will be given
separate space on the call stack for those values.
5. Pila de Evaluaci´on
Operands for arithmetic or logical operations are most often placed into registers
and operated on there. However, in some situations the operands may be stacked
up to an arbitrary depth, which means something more than registers must be
used (this is the case of register spilling). The stack of such operands, rather like
that in an RPN calculator, is called an evaluation stack, and may occupy space in
the call stack.
6. Puntero a la instancia actual
Some object-oriented languages (e.g., C++), store the this pointer along with
function arguments in the call stack when invoking methods. The this pointer
points to the object instance associated with the method to be invoked.
Los par´
ametros se siguen prefijando de $ como en la pr´actica anterior
135
var c = 4, d = 1, e;
def f(x) {
var y = 1;
x + y
:f
}
def g(a, b) {
var d, e;
def f(u, v) { a + u + v + d }
a * f(b, 2) + d + c
}
c = 3;
f(1+c);
g(3, 4)
# global:
# f: args x
# f:
var y
1
&y, 0
=
$x, 0
y, 0
+
return
# g: args a,b
# g:
var d,e
# g.f: args u,v
:g.f
$a, 1
$u, 0
+
$v, 0
+
d, 1
+
return
:g
$a, 0
$b, 0
2
call :g.f
*
d, 0
+
c, 1
+
return
Sigue un ejemplo de traducci´on:
:main:
4
&c, 0
=
1
&d, 0
=
3
&c, 0
=
1
c, 0
+
call :f
3
4
call :g
136
var c,d
Puede comenzar haciendo un fork del proyecto ull-etsii-grado-pl-infix2postfix en GitHub. Esta
incompleto. Rellene las acciones sem´
anticas que faltan; la mayor´ıa relacionadas con el an´
alisis
de ´ambito.
• Una soluci´on completa se encuentra en el proyecto crguezl/jisoninfix2postfix.
• [~/jison/jisoninfix2postfix(gh-pages)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/jison/jisoninfix2postfix
• [~/jison/jisoninfix2postfix(gh-pages)]$ git remote -v
bitbucket
ssh:[email protected]/casiano/jisoninfix2postfix.git (fetch)
bitbucket
ssh:[email protected]/casiano/jisoninfix2postfix.git (push)
origin [email protected]:crguezl/jisoninfix2postfix.git (fetch)
origin [email protected]:crguezl/jisoninfix2postfix.git (push)
Veanse:
• V´ease COMP 3290 Compiler Construction Fall 2008 Notes/Symbol Tables
• El cap´ıtulo Symbol Table Structure del libro de Muchnick Advanced Compiler Design Implementation [5]
• El cap´ıtulo Symbol Table Structure del libro de Basics of Compiler Design de Torben Ægidius Mogensen [6]
5.11.
Algoritmo de An´
alisis LR
Asi pues la tabla de transiciones del aut´omata nos genera dos tablas: la tabla de acciones y la de
saltos. El algoritmo de an´
alisis sint´actico LR en el que se basa jison utiliza una pila y dos tablas para
analizar la entrada. Como se ha visto, la tabla de acciones contiene cuatro tipo de acciones:
1. Desplazar (shift)
2. Reducir (reduce)
3. Aceptar
4. Error
El algoritmo utiliza una pila en la que se guardan los estados del aut´omata. De este modo se evita
tener que “comenzar” el procesado de la forma sentencial derecha resultante despu´es de una reducci´
on
(antiderivaci´
on).
Algoritmo 5.11.1. An´
alizador LR
push(s0);
b = yylex();
for( ; ; ;) {
s = top(0); a = b;
switch (action[s][a]) {
case "shift t" :
t.attr = a.attr;
push(t);
b = yylex();
break;
case "reduce A ->alpha" :
eval(Sem{A -> alpha}(top(|alpha|-1).attr, ... , top(0).attr));
pop(|alpha|);
push(goto[top(0)][A]);
break;
137
case "accept" : return (1);
default : yyerror("syntax error");
}
}
Como es habitual, |x| denota la longitud de la cadena x.
La funci´on top(k) devuelve el elemento que ocupa la posici´on k desde el top de la pila (esto es,
est´a a profundidad k).
La funci´on pop(k) extrae k elementos de la pila.
La notaci´
on state.attr hace referencia al atributo asociado con cada estado, el cual desde el
punto de vista del programador esta asociado con el correspondiente s´ımbolo de la parte derecha
de la regla. N´
otese que cada estado que est´a en la pila es el resultado de una transici´on con un
s´ımbolo. El atributo de ese s´ımbolo es guardado en el objeto estado cada vez que ocurre una
transici´on.
Denotamos por Sem {reduce A -> alpha} el c´odigo de la acci´on sem´
antica asociada con la
regla A → α.
Todos los analizadores LR comparten, salvo peque˜
nas excepciones, el mismo algoritmo de an´
alisis.
Lo que m´
as los diferencia es la forma en la que construyen las tablas. En jison la construcci´
on de las
tablas de acciones y gotos se realiza por defecto mediante el algoritmo LALR.
5.12.
El m´
odulo Generado por jison
5.12.1.
Version
En esta secci´
on estudiamos el analizador generado por Jison:
[~/Dropbox/src/javascript/PLgrado/jison-aSb(develop)]$ jison --version
0.4.2
5.12.2.
Gram´
atica Inicial
Veamos el m´
odulo generado por jison para esta gram´atica:
[~/srcPLgrado/aSb(develop)]$ cat aSb.jison
%lex
%%
.
{ return yytext; }
/lex
%%
S: /* empty */ { console.log("empty"); }
| ’a’ S ’b’ { console.log("S -> aSb"); }
;
%%
5.12.3.
Tablas
Esta es la primera parte del parser generado:
/* parser generated by jison 0.4.2 */
var aSb = (function() {
var parser = {
trace: function trace() {},
138
yy: {},
symbols_: {
"$accept": 0, /* super-arranque $accept -> S */
"$end": 1
/* end of input */
"error": 2, /* numero para el s´
ımbolo ’error’ */
"S": 3,
/* numero para el s´
ımbolo ’S’ */
"a": 4,
"b": 5,
},
/* array inverso de terminales */
terminals_: {
/* numero -> terminal */
2: "error",
4: "a",
5: "b"
},
productions_:
[0,
/* 1 */
[3, 0], /* S : vacio
simbolo,longitud de la parte derecha */
/* 2 */
[3, 3] /* S : a S b
simbolo,longitud */
],
5.12.4.
Acciones Sem´
anticas
Cada vez que se produce una acci´on de reducci´on esta funci´
on es llamada:
performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
var $0 = $$.length - 1;
switch (yystate) { /* yystate: numero de regla de producci´
on */
case 1:
console.log("empty");
break;
case 2:
console.log("S -> aSb");
break;
}
},
Parece que cuando se llama a este m´etodo this refiere a un objeto yyval. Este es el punto de
llamada a la acci´on sem´
antica dentro del parser generado por Jison. Puede encontrarse dentro
del parser en el caso de un switch que corresponde a la acci´on de reducci´on:
r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, l
El m´etodo call nos permite invocar una funci´on como si fuera un m´etodo de alg´
un otro objeto.
V´ease la secci´
on ??.
Este objeto yyval tiene dos atributos: $ y _$.
• El atributo $ se corresponde con $$ de la gram´atica (atributo de la variable sintactica en
la parte izquierda)
• El atributo _$ guarda informaci´
on sobre la posici´on del u
´ltimo token le´ıdo.
yytext parece contener el texto asociado con el token actual
139
Figura 5.3: DFA construido por Jison
yyleng es la longitud del token actual
yylineno es la l´ınea actual (empezando en 0)
yy es un objeto con dos atributos lexer y parser
yystate es el estado actual
$$ parece ser un array/pila conteniendo los valores de los atributos asociados con los estados de
la pila (vstack ¿Por value stack?)
Asi pues $0 es el ´ındice en $0 del u
´ltimo elemento de $$. Por ejemplo, una acci´on sem´
antica
asociada con una regla A : B C D con tres elementos como:
$$ = $1 + $2 + $3;
Se traduce por:
140
this.$ = $$[$0 - 2] + $$[$0 - 1] + $$[$0];
_$ Es un array con la informaci´
on sobre la localizaci´on de los simbolos (lstack ¿Por location
stack?)
5.12.5.
/* 0 */
/* 1 */
/* 2 */
/* 3 */
/* 4 */
Tabla de Acciones y GOTOs
table:
1:
3:
4:
}, {
1:
}, {
3:
4:
5:
}, {
5:
}, {
1:
5:
}],
[{
[2, 1],
1,
[1, 2]
/* En estado 0 viendo $end(1) reducir por S : vacio */
/* En el estado 0 viendo S(3) ir al estado 1 */
/* Estado 0 viendo a(4) shift(1) al estado 2 */
[3]
/* En 1 viendo $end(1) aceptar */
3,
[1, 2],
[2, 1]
/* En 2 viendo S ir a 3 */
/* En 2 viendo a(4) shift a 2 */
/* En 2 viendo b(5) reducir por regla 1: S -> vacio */
[1, 4]
/* En 3 viendo b(5) shift a 4 */
[2, 2],
[2, 2]
/* En 4 viendo $end(1) reducir(2) por la 2: S -> aSb */
/* En 4 viendo b(5) reducir por la 2: S-> aSb */
La tabla es un array de objetos
El ´ındice de la tabla es el estado. En el ejemplo tenemos 5 estados
El objeto/hash que es el valor contiene las acciones ante los s´ımbolos.
1. Los atributos/claves son los s´ımbolos, los valores las acciones
2. Las acciones son de dos tipos:
a) El n´
umero del estado al que se transita mediante la tabla goto cuando el s´ımbolo es
una variable sintactica
b) Un par [tipo de acci´
on, estado o regla]. Si el tipo de acci´
on es 1 indica un
shift al estado con ese n´
umero. Si el tipo de acci´
on es 2 indica una reducci´on por la
regla con ese n´
umero.
3. Por ejemplo table[0] es
{
1: [2, 1],
3: 1,
4: [1, 2]
/* En estado 0 viendo $end(1) reducir(2) por S : vacio */
/* En el estado 0 viendo S(3) ir (goto) al estado 1 */
/* Estado 0 viendo a(4) shift(1) al estado 2 */
}
5.12.6.
defaultActions
defaultActions: {},
defaultActions contiene las acciones por defecto.
Despu´es de la construcci´
on de la tabla, Jison identifica para cada estado la reducci´on que tiene
el conjunto de lookaheads mas grande. Para reducir el tama˜
no del parser, Jison puede decidir
suprimir dicho conjunto y asiganr esa reducci´on como acci´
on del parser por defecto. Tal reducci´
on
se conoce como reducci´
on por defecto.
141
Esto puede verse en este segmento del c´odigo del parser:
while (true) {
state = stack[stack.length - 1];
if (this.defaultActions[state]) {
action = this.defaultActions[state];
} else {
if (symbol === null || typeof symbol == "undefined") {
symbol = lex();
}
action = table[state] && table[state][symbol];
}
...
}
5.12.7.
Reducciones
parse: function parse(input) {
...
while (true) {
state = stack[stack.length - 1];
if (this.defaultActions[state]) {
action = this.defaultActions[state];
} else {
if (symbol === null || typeof symbol == "undefined") {
symbol = lex(); /* obtener siguiente token */
}
action = table[state] && table[state][symbol];
}
if (typeof action === "undefined" || !action.length || !action[0]) {
... // error
}
if (action[0] instanceof Array && action.length > 1) {
throw new Error("Parse Error: multiple actions possible at state: ..."
}
switch (action[0]) {
case 1:
// shift
...
break;
case 2:
// reduce
len = this.productions_[action[1]][1]; // longitud de la producci´
on
yyval.$ = vstack[vstack.length - len];
yyval._$ = {
// datos de la posici´
on
first_line: lstack[lstack.length - (len || 1)].first_line,
last_line: lstack[lstack.length - 1].last_line,
first_column: lstack[lstack.length - (len || 1)].first_column,
last_column: lstack[lstack.length - 1].last_column
};
...
r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1
if (typeof r !== "undefined") {
return r; /* un return de algo distinto de undefined nos saca del parser *
}
if (len) {
/* retirar de las pilas */
142
stack = stack.slice(0, - 1 * len * 2);
vstack = vstack.slice(0, - 1 * len);
lstack = lstack.slice(0, - 1 * len);
/* simbolo, estado, simbolo, estad
/* retirar atributos */
/* retirar localizaciones */
}
stack.push(this.productions_[action[1]][0]); /* empujemos el s´
ımbolo */
vstack.push(yyval.$);
/* empujemos valor semantico */
lstack.push(yyval._$);
/* empujemos localizaci´
on */
newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
stack.push(newState);
/* empujemos goto[top][A]*/
break;
case 3: // accept
return true;
}
}
return true;
}
5.12.8.
Desplazamientos/Shifts
parse: function parse(input) {
...
while (true) {
state = stack[stack.length - 1];
/* estado en el top de la pila */
if (this.defaultActions[state]) {
/* definida la acci´
on por defecto? */
action = this.defaultActions[state];
} else {
if (symbol === null || typeof symbol == "undefined") {
symbol = lex();
/* obtener token */
}
action = table[state] && table[state][symbol]; /* obtener la acci´
on para el estado
}
if (typeof action === "undefined" || !action.length || !action[0]) {
... /* error */
}
if (action[0] instanceof Array && action.length > 1) {
throw new Error("Parse Error: multiple actions possible at state: " + state + ", t
}
switch (action[0]) {
case 1:
stack.push(symbol);
/* empujamos token */
vstack.push(this.lexer.yytext);
/* empujamos el atributo del token */
lstack.push(this.lexer.yylloc);
/* salvamos la localizaci´
on del token */
stack.push(action[1]);
/* salvamos el estado */
symbol = null;
if (!preErrorSymbol) {
/* si no hay errores ... */
yyleng = this.lexer.yyleng;
/* actualizamos los atributos */
yytext = this.lexer.yytext;
/* del objeto */
yylineno = this.lexer.yylineno;
yyloc = this.lexer.yylloc;
if (recovering > 0) recovering--; /* las cosas van mejor si hubieron error
} else {
symbol = preErrorSymbol;
preErrorSymbol = null;
}
143
break;
case 2:
...
break;
case 3:
return true;
}
}
return true;
}
5.12.9.
Manejo de Errores
while (true) {
state = stack[stack.length - 1];
if (this.defaultActions[state]) { action = this.defaultActions[state]; }
else {
if (symbol === null || typeof symbol == "undefined") { symbol = lex(); }
action = table[state] && table[state][symbol];
}
if (typeof action === "undefined" || !action.length || !action[0]) {
var errStr = "";
if (!recovering) { /* recovering = en estado de recuperaci´
on de un error */
expected = [];
/* computemos los tokens esperados */
for (p in table[state])
/* si el estado "state" transita con p */
if (this.terminals_[p] && p > 2) { /* y "p" es un terminal no especial */
expected.push("’" + this.terminals_[p] + "’"); /* entonces es esperado */
}
if (this.lexer.showPosition) { /* si esta definida la funci´
on showPosition */
errStr = "Parse error on line " + (yylineno + 1) +
":\n" + this.lexer.showPosition() +
"\nExpecting " + expected.join(", ") +
", got ’" +
(this.terminals_[symbol] || symbol) + /* terminals_ es el array inver
"’";
/* numero -> terminal
} else { /* ¡monta la cadena como puedas! */
errStr = "Parse error on line " + (yylineno + 1) +
": Unexpected " +
(symbol == 1 ? "end of input" : "’" +
(this.terminals_[symbol] || symbol) + "’");
}
this.parseError(errStr, {
/* genera la excepci´
on */
text: this.lexer.match, /* hash/objeto conteniendo los detalles del */
token: this.terminals_[symbol] || symbol,
/* error */
line: this.lexer.yylineno,
loc: yyloc,
expected: expected
});
}
}
if (action[0] instanceof Array && action.length > 1) {
throw new Error("Parse Error: multiple actions possible at state: " + state + ", token
}
...
144
}
La funci´on parseError genera una excepci´
on:
parseError: function parseError(str, hash) {
throw new Error(str); /* El hash contiene info sobre el error: token, linea, etc.
},
parseError es llamada cada vez que ocurre un error sint´actico. str contiene la cadena con el
mensaje de error del tipo: Expecting something, got other thing’. hash contiene atributos
como expected: el array de tokens esperados; line la l´ınea implicada, loc una descripci´
on de
la localizaci´on detallada del punto/terminal en el que ocurre el error; etc.
5.12.10.
Analizador L´
exico
El analizador l´exico:
/* generated by jison-lex 0.1.0 */
var lexer = (function() {
var lexer = {
EOF: 1,
parseError: function parseError(str, hash) { /* manejo de errores l´
exicos */ },
setInput: function(input) { /* inicializar la entrada para el analizadorl´
exico */},
input: function() { /* ... */ },
unput: function(ch) { /* devolver al flujo de entrada */ },
more: function() { /* ... */ },
less: function(n) { /* ... */ },
pastInput: function() { /* ... */ },
upcomingInput: function() { /* ... */ },
showPosition: function() { /* ... */ },
next: function() {
if (this.done) { return this.EOF; }
if (!this._input) this.done = true;
var token, match, tempMatch, index, col, lines;
if (!this._more) { this.yytext = ’’; this.match = ’’; }
var rules = this._currentRules();
for (var i = 0; i < rules.length; i++) {
tempMatch = this._input.match(this.rules[rules[i]]);
if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
match = tempMatch;
index = i;
if (!this.options.flex) break;
}
}
if (match) {
lines = match[0].match(/(?:\r\n?|\n).*/g);
if (lines) this.yylineno += lines.length;
this.yylloc = {
first_line: this.yylloc.last_line,
last_line: this.yylineno + 1,
first_column: this.yylloc.last_column,
last_column:
lines ? lines[lines.length - 1].length lines[lines.length - 1].match(/\r?\n?/)[0].length
145
:
this.yylloc.last_column + match[0].length
};
this.yytext += match[0];
this.match += match[0];
this.matches = match;
this.yyleng = this.yytext.length;
if (this.options.ranges) {
this.yylloc.range = [this.offset, this.offset += this.yyleng];
}
this._more = false;
this._input = this._input.slice(match[0].length);
this.matched += match[0];
token = this.performAction.call(
this,
this.yy,
this,
rules[index],
this.conditionStack[this.conditionStack.length - 1]
);
if (this.done && this._input) this.done = false;
if (token) return token;
else return;
}
if (this._input === "") { return this.EOF; }
else {
return this.parseError(
’Lexical error on line ’ + (this.yylineno + 1) +
’. Unrecognized text.\n’ + this.showPosition(),
{ text: "", token: null, line: this.yylineno }
);
}
},
lex: function lex() {
var r = this.next();
if (typeof r !== ’undefined’) {
return r;
} else {
return this.lex();
}
},
begin: function begin(condition) { },
popState: function popState() { },
_currentRules: function _currentRules() { },
topState: function() { },
pushState: function begin(condition) { },
options: {},
performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START)
{
var YYSTATE = YY_START;
switch ($avoiding_name_collisions) {
case 0:
return yy_.yytext;
146
break;
}
},
rules: [/^(?:.)/], /* lista de expresiones regulares */
conditions: { /* ... */ }
}
};
5.12.11.
Exportaci´
on
Si no ha sido exportado ya ...
if (typeof require !== ’undefined’ && typeof exports !== ’undefined’) {
exports.parser = aSb;
/* hacemos accesible el objeto aSb */
exports.Parser = aSb.Parser;
El objeto aSb.Parser representa al parser. Este es el c´odigo que lo crea.
function Parser() {
this.yy = {};
}
Parser.prototype = parser;
parser.Parser = Parser;
return new Parser;
})();
Tambi´en se exporta una funci´on parse:
exports.parse = function() {
return aSb.parse.apply(aSb, arguments);
};
y una funci´on main:
exports.main = function commonjsMain(args) {
if (!args[1]) {
console.log(’Usage: ’ + args[0] + ’ FILE’);
process.exit(1);
}
var source = require(’fs’).readFileSync(require(’path’).normalize(args[1]), "utf8");
return exports.parser.parse(source);
};
if (typeof module !== ’undefined’ && require.main === module) {
exports.main(process.argv.slice(1));
}
}
Esto permite ejecutar el m´
odulo directamente:
[~/Dropbox/src/javascript/PLgrado/jison-aSb(develop)]$ node aSb.js input.ab
empty
S -> aSb
S -> aSb
[~/Dropbox/src/javascript/PLgrado/jison-aSb(develop)]$ cat input.ab
aabb
147
~/Dropbox/src/javascript/PLgrado/jison-aSb(develop)]$ node debug aSb.js input.ab
< debugger listening on port 5858
connecting... ok
break in aSb.js:2
1 /* parser generated by jison 0.4.2 */
2 var aSb = (function() {
3
var parser = {
4
trace: function trace() {},
debug> n
break in aSb.js:390
388
return new Parser;
389 })();
390 if (typeof require !== ’undefined’ && typeof exports !== ’undefined’) {
391
exports.parser = aSb;
392
exports.Parser = aSb.Parser;
debug> repl
Press Ctrl + C to leave debug repl
>
> typeof require
’function’
> typeof exports
’object’
> aSb
{ yy: {} }
> aSb.Parser
[Function]
^C
debug> sb(396)
395
};
debug> c
break in aSb.js:396
394
return aSb.parse.apply(aSb, arguments);
395
};
*396
exports.main = function commonjsMain(args) {
397
if (!args[1]) {
398
console.log(’Usage: ’ + args[0] + ’ FILE’);
debug> n
break in aSb.js:404
402
return exports.parser.parse(source);
403
};
404
if (typeof module !== ’undefined’ && require.main === module) {
405
exports.main(process.argv.slice(1));
406
}
debug> repl
Press Ctrl + C to leave debug repl
> process.argv.slice(1)
[ ’/Users/casiano/Dropbox/src/javascript/PLgrado/jison-aSb/aSb.js’,
’input.ab’ ]
> typeof module
’object’
> require.main
{ id: ’.’,
exports:
148
{ parser: { yy: {} },
Parser: [Function],
parse: [Function],
main: [Function] },
parent: null,
filename: ’/Users/casiano/Dropbox/src/javascript/PLgrado/jison-aSb/aSb.js’,
loaded: false,
children: [],
paths:
[ ’/Users/casiano/Dropbox/src/javascript/PLgrado/jison-aSb/node_modules’,
’/Users/casiano/Dropbox/src/javascript/PLgrado/node_modules’,
’/Users/casiano/Dropbox/src/javascript/node_modules’,
’/Users/casiano/Dropbox/src/node_modules’,
’/Users/casiano/Dropbox/node_modules’,
’/Users/casiano/node_modules’,
’/Users/node_modules’,
’/node_modules’ ] }
^C
debug> n
break in aSb.js:405
403
};
404
if (typeof module !== ’undefined’ && require.main === module) {
405
exports.main(process.argv.slice(1));
406
}
407 }
debug> n
< empty
< S -> aSb
< S -> aSb
break in aSb.js:409
407 }
408
409 });
debug> c
program terminated
debug>
5.13.
Precedencia y Asociatividad
Recordemos que si al construir la tabla LALR, alguna de las entradas de la tabla resulta multievaluada, decimos que existe un conflicto. Si una de las acciones es de ‘reducci´
on” y la otra es de
‘desplazamiento”, se dice que hay un conflicto shift-reduce o conflicto de desplazamiento-reducci´
on.
Si las dos reglas indican una acci´on de reducci´on, decimos que tenemos un conflicto reduce-reduce o
de reducci´
on-reducci´
on. En caso de que no existan indicaciones espec´ıficas jison resuelve los conflictos
que aparecen en la construcci´
on de la tabla utilizando las siguientes reglas:
1. Un conflicto reduce-reduce se resuelve eligiendo la producci´
on que se list´o primero en la especificaci´on de la gram´atica.
2. Un conflicto shift-reduce se resuelve siempre en favor del shift
Las declaraciones de precedencia y asociatividad mediante las palabras reservadas %left , %right ,
%nonassoc se utilizan para modificar estos criterios por defecto. La declaraci´on de token s mediante
149
la palabra reservada %token no modifica la precedencia. Si lo hacen las declaraciones realizadas
usando las palabras left , right y nonassoc .
1. Los tokens declarados en la misma l´ınea tienen igual precedencia e igual asociatividad. La precedencia es mayor cuanto mas abajo su posici´on en el texto. As´ı, en el ejemplo de la calculadora
en la secci´
on ??, el token * tiene mayor precedencia que + pero la misma que /.
2. La precedencia de una regla A → α se define como la del terminal mas a la derecha que aparece
en α. En el ejemplo, la producci´
on
expr : expr ’+’ expr
tiene la precedencia del token +.
3. Para decidir en un conflicto shift-reduce se comparan la precedencia de la regla con la del terminal
que va a ser desplazado. Si la de la regla es mayor se reduce si la del token es mayor, se desplaza.
4. Si en un conflicto shift-reduce ambos la regla y el terminal que va a ser desplazado tiene la
misma precedencia jison considera la asociatividad, si es asociativa a izquierdas, reduce y si es
asociativa a derechas desplaza. Si no es asociativa, genera un mensaje de error.
Obs´ervese que, en esta situaci´on, la asociatividad de la regla y la del token han de ser por fuerza,
las mismas. Ello es as´ı, porque en jison los tokens con la misma precedencia se declaran en la
misma l´ınea y s´
olo se permite una declaraci´
on por l´ınea.
5. Por tanto es imposible declarar dos tokens con diferente asociatividad y la misma precedencia.
6. Es posible modificar la precedencia “natural” de una regla, calific´
andola con un token espec´ıfico. para ello se escribe a la derecha de la regla prec token, donde token es un token con la
precedencia que deseamos. Vea el uso del token dummy en el siguiente ejercicio.
Para ilustrar las reglas anteriores usaremos el siguiente programa jison:
[~/jison/jison-prec(ast)]$ cat -n precedencia.jison
1 %token NUMBER
2 %left [email protected]
3 %right ’&’ dummy
4 %%
5 s
6
: list
{ console.log($list); }
7
;
8
9 list
10
:
11
{
12
$$ = [];
13
}
14
| list ’\n’
15
{
16
$$ = $1;
17
}
18
| list e
19
{
20
$$ = $1;
21
$$.push($e);
22
}
150
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
;
e : NUMBER
{
$$ = "NUMBER ("+yytext+")";
}
| e ’&’ e
{
$$ = [ "&", $e1, $e2];
}
| e [email protected] e %prec dummy
{
$$ = ["@", $e1, $e2];
}
;
%%
Obs´ervese la siguiente ejecuci´
on:
[~/jison/jison-prec(ast)]$ cat input.txt
[email protected]@4
2&3&4
[~/jison/jison-prec(ast)]$ node precedencia.js input.txt
[ [ [email protected], [ [email protected], ’NUMBER (2)’, ’NUMBER (3)’ ], ’NUMBER (4)’ ],
[ ’&’, ’NUMBER (2)’, [ ’&’, ’NUMBER (3)’, ’NUMBER (4)’ ] ] ]
Compilamos a continuaci´
on con bison usando la opci´
on -v para producir informaci´
on sobre los
conflictos y las tablas de salto y de acciones:
[~/jison/jison-prec(ast)]$ bison -v precedencia.jison
precedencia.jison:6.31: warning: stray ‘$’
precedencia.jison:21.27: warning: stray ‘$’
precedencia.jison:31.31: warning: stray ‘$’
precedencia.jison:31.36: warning: stray ‘$’
precedencia.jison:35.30: warning: stray ‘$’
precedencia.jison:35.35: warning: stray ‘$’
La opci´
on -v genera el fichero Precedencia.output el cual contiene informaci´
on detallada sobre
el aut´omata:
[~/jison/jison-prec(ast)]$ cat precedencia.output
Grammar
0 $accept: s $end
1 s: list
2 list: /* empty */
3
| list ’\n’
4
| list e
5 e: NUMBER
6 | e ’&’ e
7 | e [email protected] e
151
Terminals, with rules where they appear
$end (0) 0
’\n’ (10) 3
’&’ (38) 6
[email protected] (64) 7
error (256)
NUMBER (258) 5
dummy (259)
Nonterminals, with rules where they appear
$accept (8)
on left:
s (9)
on left:
list (10)
on left:
e (11)
on left:
0
1, on right: 0
2 3 4, on right: 1 3 4
5 6 7, on right: 4 6 7
state 0
0 $accept: . s $end
$default
s
list
reduce using rule 2 (list)
go to state 1
go to state 2
state 1
0 $accept: s . $end
$end
shift, and go to state 3
state 2
1 s: list .
3 list: list . ’\n’
4
| list . e
NUMBER
’\n’
$default
shift, and go to state 4
shift, and go to state 5
reduce using rule 1 (s)
152
e
go to state 6
state 3
0 $accept: s $end .
$default
accept
state 4
5 e: NUMBER .
$default
reduce using rule 5 (e)
state 5
3 list: list ’\n’ .
$default
reduce using rule 3 (list)
state 6
4 list: list e .
6 e: e . ’&’ e
7 | e . [email protected] e
[email protected]
’&’
shift, and go to state 7
shift, and go to state 8
$default
reduce using rule 4 (list)
state 7
7 e: e [email protected] . e
NUMBER
e
shift, and go to state 4
go to state 9
state 8
6 e: e ’&’ . e
NUMBER
e
shift, and go to state 4
go to state 10
153
state 9
6 e: e . ’&’ e
7 | e . [email protected] e
7 | e [email protected] e .
’&’
shift, and go to state 8
$default
reduce using rule 7 (e)
state 10
6 e: e . ’&’ e
6 | e ’&’ e .
7 | e . [email protected] e
’&’
shift, and go to state 8
$default
reduce using rule 6 (e)
La presencia de conflictos, aunque no siempre, en muchos casos es debida a la introducci´
on de ambiguedad en la gram´atica. Si el conflicto es de desplazamiento-reducci´
on se puede resolver explicitando
alguna regla que rompa la ambiguedad. Los conflictos de reducci´on-reducci´
on suelen producirse por
un dise˜
no err´oneo de la gram´atica. En tales casos, suele ser mas adecuado modificar la gram´atica.
5.14.
Esquemas de Traducci´
on
Un esquema de traducci´
on es una gram´atica independiente del contexto en la cu´
al se han asociado
atributos a los s´ımbolos de la gram´atica. Un atributo queda caracterizado por un identificador o nombre
y un tipo o clase. Adem´
as se han insertado acciones, esto es, c´odigo JavaScript/Perl/Python/C, . . . en
medio de las partes derechas. En ese c´odigo es posible referenciar los atributos de los s´ımbolos de la
gram´atica como variables del lenguaje subyacente.
Recuerde que el orden en que se eval´
uan los fragmentos de c´odigo es el de un recorrido primeroprofundo del ´arbol de an´
alisis sint´actico. Mas espec´ıficamente, considerando a las acciones como hijoshoja del nodo, el recorrido que realiza un esquema de traducci´on es:
1
2
3
4
5
6
7
8
9
10
function esquema_de_traduccion(node) {
for(c in node.children) { # de izquierda a derecha
child = node.children[i];
if (child.instanceof(’SemanticAction’) { # si es una acci´
on sem´
antica
child.execute;
}
else { esquema_de_traduccion(child) }
}
}
Obs´ervese que, como el bucle recorre a los hijos de izquierda a derecha, se debe dar la siguiente
condici´
on para que un esquema de traducci´on funcione:
Para cualquier regla de producci´
on aumentada con acciones, de la forma
A → X1 . . . Xj { action(A{b}, X1 {c}. . . Xn {d})}Xj+1 . . . Xn
154
debe ocurrir que los atributos evaluados en la acci´on insertada despu´es de Xj dependan de atributos
y variables que fueron computadas durante la visita de los hermanos izquierdos o de sus ancestros. En
particular no deber´ıan depender de atributos asociados con las variables Xj+1 . . . Xn . Ello no significa
que no sea correcto evaluar atributos de Xj+1 . . . Xn en esa acci´on.
Por ejemplo, el siguiente esquema no satisface el requisito:
porque cuando vas a ejecutar la acci´on { console.log(A.in) } el atributo A.in no ha sido
computado.
Los atributos de cada s´ımbolo de la gram´atica X ∈ V ∪ Σ se dividen en dos grupos disjuntos:
atributos sintetizados y atributos heredados:
Un atributo de X es un atributo heredado si depende de atributos de su padre y herm´anos en el
´arbol.
Un atributo sintetizado es aqu´el tal que el valor del atributo depende de los valores de los
atributos de los hijos, es decir en tal caso X ha de ser una variable sint´actica y los atributos en
la parte derecha de la regla sem´
antica deben ser atributos de s´ımbolos en la parte derecha de la
regla de producci´
on asociada.
5.15.
Manejo en jison de Atributos Heredados
Supongamos que jison esta inmerso en la construcci´
on de la antiderivaci´
on a derechas y que la
forma sentencial derecha en ese momento es:
X m . . . X1 X 0 Y 1 . . . Y n a 1 . . . a 0
y que el mango es B → Y1 . . . Yn y en la entrada quedan por procesar a1 . . . a0 .
No es posible acceder en jison a los valores de los atributos de los estados en la pila del analizador
que se encuentran “por debajo” o si se quiere “a la izquierda” de los estados asociados con la regla
por la que se reduce.
Vamos a usar un peque˜
no hack para acceder a los atributos asociados con s´ımbolos vistos en el
pasado remoto”:
[~/jison/jison-inherited(grammar)]$ cat inherited.jison
%lex
%%
155
\s+
(global|local|integer|float)
[a-zA-Z_]\w*
.
/lex
%%
D
: C T L
;
{}
{ return yytext; }
{ return ’id’; }
{ return yytext; }
C
: global
| local
;
T
: integer
| float
;
L
: L ’,’ id
{
console.log("L -> L ’,’ id ("+yytext+")");
var s = eval(’$$’);
console.log(s);
| id
}
{
console.log("L -> id ("+yytext+")");
var s = eval(’$$’);
console.log(s);
}
;
%%
Veamos un ejemplo de ejecuci´
on:
[~/jison/jison-inherited(grammar)]$ cat input.txt
global integer a, b, c
[~/jison/jison-inherited(grammar)]$ node inherited.js input.txt
L -> id (a)
[ null, ’global’, ’integer’, ’a’ ]
L -> L ’,’ id (b)
[ null, ’global’, ’integer’, ’a’, ’,’, ’b’ ]
L -> L ’,’ id (c)
[ null, ’global’, ’integer’, ’a’, ’,’, ’c’ ]
Esta forma de acceder a los atributos es especialmente u
´til cuando se trabaja con atributos heredados. Esto es, cuando un atributo de un nodo del ´arbol sint´actico se computa en t´erminos de valores
de atributos de su padre y/o sus hermanos. Ejemplos de atributos heredados son la clase y tipo en la
declaraci´
on de variables.
Es importante darse cuenta que en cualquier derivaci´
on a derechas desdeD, cuando se reduce por
una de las reglas
L → id | L1 ’,’ id
156
el s´ımbolo a la izquierda de L es T y el que esta a la izquierda de T es C. Considere, por ejemplo
la derivaci´
on a derechas:
D =⇒ C T L =⇒ C T L, id =⇒ C T L, id, id =⇒ C T id, id, id =⇒
=⇒ C float id, id, id =⇒ local float id, id, id
Observe que el orden de recorrido de jison es:
local float id, id, id ⇐= C float id, id ⇐= C T id, id, id ⇐=
⇐= C T L, id, id ⇐= C T L, id ⇐= C T L ⇐= D
en la antiderivaci´
on, cuando el mango es una de las dos reglas para listas de identificadores, L → id y
L → L, id es decir durante las tres ultimas antiderivaciones:
C T L, id, id ⇐= C T L, id ⇐= C T L ⇐= D
las variables a la izquierda del mango son T y C. Esto ocurre siempre. Estas observaciones nos conducen
al siguiente programa jison:
[~/jison/jison-inherited(deepstack)]$ cat inherited.jison
%lex
%%
\s+
{}
(global|local|integer|float) { return yytext; }
[a-zA-Z_]\w*
{ return ’id’; }
.
{ return yytext; }
/lex
%%
D
: C T L
;
C
: global
| local
;
T
: integer
| float
;
L
: L ’,’ id
{
var s = eval(’$$’);
var b0 = s.length - 3;
console.log("L -> L ’,’ id ("+yytext+")");
console.log($id + ’ is of type ’ + s[b0-1]);
console.log(s[b0] + ’ is of class ’ + s[b0-2]);
| id
}
{
var s = eval(’$$’);
var b0 = s.length - 1;
157
console.log("L -> id ("+yytext+")");
console.log($id + ’ is of type ’ + s[b0-1]);
console.log(s[b0] + ’ is of class ’ + s[b0-2]);
}
;
%%
A continuaci´
on sigue un ejemplo de ejecuci´
on:
[~/jison/jison-inherited(deepstack)]$ node inherited.js input.txt
L -> id (a)
a is of type integer
a is of class global
L -> L ’,’ id (b)
b is of type integer
a is of class global
L -> L ’,’ id (c)
c is of type integer
a is of class global
En este caso, existen varias alternativas simples a esta soluci´on:
Montar la lista de identificadores en un array y ponerles el tipo y la clase de ”golpe.en la regla
de producci´
on superior D : C T L ;
usar variables visibles (globales o atributos del objeto parser, por ejemplo) como current_type,
current_class
C
: global { current_class = ’global’; }
| local { current_class = ’local’; }
y depu´es accederlas en las reglas de L
La que posiblemente sea la mejor estrategia general: construir el ´arbol de an´
alisis sint´actico.
Posteriormente podemos recorrer el ´arbol como queramos y tantas veces como queramos.
5.16.
Definici´
on Dirigida por la Sint´
axis
Una definici´
on dirigida por la sint´
axis es un pariente cercano de los esquemas de traducci´on.
En una definici´on dirigida por la sint´axis una gram´atica G = (V, Σ, P, S) se aumenta con nuevas
caracter´ısticas:
A cada s´ımbolo S ∈ V ∪ Σ de la gram´atica se le asocian cero o mas atributos. Un atributo
queda caracterizado por un identificador o nombre y un tipo o clase. A este nivel son atributos
formales, como los par´
ametros formales, en el sentido de que su realizaci´on se produce cuando
el nodo del ´
arbol es creado.
A cada regla de producci´
on A → X1 X2 . . . Xn ∈ P se le asocian un conjunto de reglas de
evaluaci´
on de los atributos o reglas sem´
anticas que indican que el atributo en la parte izquierda
de la regla sem´
antica depende de los atributos que aparecen en la parte derecha de la regla. El
atributo que aparece en la parte izquierda de la regla sem´
antica puede estar asociado con un
s´ımbolo en la parte derecha de la regla de producci´
on.
158
Los atributos de cada s´ımbolo de la gram´atica X ∈ V ∪ Σ se dividen en dos grupos disjuntos:
atributos sintetizados y atributos heredados. Un atributo de X es un atributo heredado si depende
de atributos de su padre y herm´anos en el ´arbol. Un atributo sintetizado es aqu´el tal que el valor
del atributo depende de los valores de los atributos de los hijos, es decir en tal caso X ha de
ser una variable sint´actica y los atributos en la parte derecha de la regla sem´
antica deben ser
atributos de s´ımbolos en la parte derecha de la regla de producci´
on asociada.
Los atributos predefinidos se denomin´
an atributos intr´ınsecos. Ejemplos de atributos intr´ınsecos
son los atributos sintetizados de los terminales, los cu´
ales se han computado durante la fase de
an´
alisis l´exico. Tambi´en son atributos intr´ınsecos los atributos heredados del s´ımbolo de arranque,
los cuales son pasados como par´
ametros al comienzo de la computaci´
on.
La diferencia principal con un esquema de traducci´on est´a en que no se especifica el orden de
ejecuci´
on de las reglas sem´
anticas. Se asume que, bien de forma manual o autom´atica, se resolver´an
las dependencias existentes entre los atributos determinadas por la aplicaci´on de las reglas sem´
anticas,
de manera que ser´an evaluados primero aquellos atributos que no dependen de ning´
un otro, despues los
que dependen de estos, etc. siguiendo un esquema de ejecuci´
on que viene guiado por las dependencias
existentes entre los datos.
Aunque hay muchas formas de realizar un evaluador de una definici´on dirigida por la sint´axis,
conceptualmente, tal evaluador debe:
1. Construir el ´
arbol de an´
alisis sint´actico para la gram´atica y la entrada dadas.
2. Analizar las reglas sem´
anticas para determinar los atributos, su clase y las dependencias entre
los mismos.
3. Construir el grafo de dependencias de los atributos, el cual tiene un nodo para cada ocurrencia
de un atributo en el ´
arbol de an´
alisis sint´actico etiquetado con dicho atributo. El grafo tiene una
arista entre dos nodos si existe una dependencia entre los dos atributos a trav´es de alguna regla
sem´
antica.
4. Supuesto que el grafo de dependencias determina un orden parcial (esto es cumple las propiedades reflexiva, antisim´etrica y transitiva) construir un orden topol´
ogico compatible con el orden
parcial.
5. Evaluar las reglas sem´
anticas de acuerdo con el orden topol´ogico.
Una definici´on dirigida por la sint´axis en la que las reglas sem´
anticas no tienen efectos laterales se
denomina una gram´
atica atribu´ıda.
Si la definici´on dirigida por la sint´axis puede ser realizada mediante un esquema de traducci´on
se dice que es L-atribu´ıda. Para que una definici´on dirigida por la sint´axis sea L-atribu´ıda deben
cumplirse que cualquiera que sea la regla de producci´
on A → X1 . . . Xn , los atributos heredados de
Xj pueden depender u
´nicamente de:
1. Los atributos de los s´ımbolos a la izquierda de Xj
2. Los atributos heredados de A
N´
otese que las restricciones se refieren a los atributos heredados. El c´alculo de los atributos sintetizados no supone problema para un esquema de traducci´on. Si la gram´atica es LL(1), resulta f´acil
realizar una definici´on L-atribu´ıda en un analizador descendente recursivo predictivo.
Si la definici´on dirigida por la sint´axis s´
olo utiliza atributos sintetizados se denomina S-atribu´ıda.
Una definici´on S-atribu´ıda puede ser f´acilmente trasladada a un programa jison.
Ejercicio 5.16.1. El siguiente es un ejemplo de definici´
on dirigida por la sint´
axis:
159
S→aAC
S→bABC
C→c
A→a
B→b
$C{i}
$C{i}
$C{s}
$A{s}
$B{s}
=
=
=
=
=
$A{s}
$A{s}
$C{i}
"a"
"b"
Determine un orden correcto de evaluaci´
on de la anterior definici´
on dirigida por la sint´
axis para
la entrada b a b c.
Ejercicio 5.16.2.
Lea el art´ıculo Are Attribute Grammars used in Industry? por Josef Grosch
I am observing a lack of education and knowledge about compiler construction in industry.
When I am asking the participants of our trainings or the employees we met in our projects
then only few people have learned about compiler construction during their education. For
many of them compiler construction has a bad reputation because of what and how they
have learned about this topic. Even fewer people have a usable knowledge about compilers.
Even fewer people know about the theory of attribute grammars. And even fewer people
know how to use attribute grammars for solving practical problems. Nevertheless, attribute
grammars are used in industry. However, in many cases the people in industry do not
know about this fact. They are running prefabricated subsystems constructed by external
companies such as ours. These subsystems are for example parsers which use attribute
grammar technology.
5.17.
Ejercicios: Casos de Estudio
V´ease nuestro proyecto Grammar Repository en GoogleCode.
5.17.1.
Un mal dise˜
no
Ejercicio 5.17.1. This grammar
%token D S
%%
p: ds ’;’ ss
ds: D ’;’ ds
| D
;
ss: S ’;’ ss
%%
| ss ;
| S
;
illustrates a typical LALR conflict due to a bad grammar design.
Reescriba la gram´
atica para que no existan conflictos
Escriba las acciones sem´
anticas necesarias para imprimir la lista de Ds seguida de la lista de Ss
Donde
[~/jison/jison-decs-sts(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/jison/jison-decs-sts
[~/jison/jison-decs-sts(master)]$ git remote -v
origin [email protected]:crguezl/jison-decs-sts.git (fetch)
origin [email protected]:crguezl/jison-decs-sts.git (push)
https://github.com/crguezl/jison-decs-sts
160
5.17.2.
Gram´
atica no LR(1)
La siguiente gram´atica no es LR(1).
[~/srcPLgrado/jison/jison-nolr]$ cat confusingsolvedppcr.y
%%
A:
B ’c’ ’d’
| E ’c’ ’f’
;
B:
’x’ ’y’
;
E:
’x’ ’y’
;
%%
Encuentre una gram´atica sin conflictos equivalente a la anterior.
Donde
[~/jison/jison-nolr(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/jison/jison-nolr
[~/jison/jison-nolr(master)]$ git remote -v
origin [email protected]:crguezl/jison-nolr.git (fetch)
origin [email protected]:crguezl/jison-nolr.git (push)
https://github.com/crguezl/jison-nolr
5.17.3.
Un Lenguaje Intr´ınsecamente Ambiguo
Ejercicio 5.17.2. A context-free language is inherently ambiguous if all context-free grammars generating that language are ambiguous. While some context-free languages have both ambiguous and
unambiguous grammars, there are context-free languages for which no unambiguous context-free grammar can exist. An example of an inherently ambiguous language is the set
{ a^n b^n c^m : n >= 0, m >= 0 } U { a^n b^m c^m : n >= 0, m >= 0 }
Esto es: Concatenaciones de repeticiones de as seguidas de repeticiones de bs y seguidas de repeticiones de cs donde el n´
umero de as es igual al n´
umero de bs o bien el n´
umero de bs es igual al n´
umero
de cs.
Escriba una gram´
atica que genere dicho lenguaje
s: aeqb | beqc ;
aeqb: ab cs ;
ab: /* empty */ |
cs: /* empty */ |
beqc: as bc ;
bc: /* empty */ |
as: /* empty */ |
’a’ ab ’b’ ;
cs ’c’ ;
’b’ bc ’c’ ;
as ’a’ ;
The symbol aeqb correspond to guess that there are the same number of as than bs. In the
same way, beqc starts the subgrammar for those phrases where the number of bs is equal to the
number of cs. The usual approach to eliminate the ambiguity by changing the grammar to an
unambiguous one does not work.
161
Escriba un programa Jison que reconozca este lenguaje.
Donde
[~/jison/jison-ambiguouslanguage(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/jison/jison-ambiguouslanguage
[~/jison/jison-ambiguouslanguage(master)]$ git remote -v
origin [email protected]:crguezl/jison-ambiguouslanguage.git (fetch)
origin [email protected]:crguezl/jison-ambiguouslanguage.git (push)
https://github.com/crguezl/jison-ambiguouslanguage
5.17.4.
Conflicto reduce-reduce
La siguiente gram´atica presenta conflictos reduce-reduce:
Ejercicio 5.17.3. [~/srcPLgrado/jison/jison-reducereduceconflict]$ cat reducereduceconflictPPCR2
%token ID
%%
def:
param_spec return_spec ’,’
;
param_spec:
type
|
name_list ’:’ type
;
return_spec:
type
|
name ’:’ type
;
type:
ID
;
name:
ID
;
name_list:
name
|
name ’,’ name_list
;
%%
Este es el diagn´
ostico de Jison:
~/srcPLgrado/jison/jison-reducereduceconflict]$ jison reducereduceconflictPPCR2.y
Conflict in grammar: multiple actions possible when lookahead token is ID in state 5
- reduce by rule: name -> ID
- reduce by rule: type -> ID
Conflict in grammar: multiple actions possible when lookahead token is : in state 5
- reduce by rule: name -> ID
- reduce by rule: type -> ID
Conflict in grammar: multiple actions possible when lookahead token is , in state 5
- reduce by rule: name -> ID
- reduce by rule: type -> ID
162
States with conflicts:
State 5
type -> ID . #lookaheads= ID : ,
name -> ID . #lookaheads= ID : ,
Este es el resultado de compilar con bison -v:
[~/jison/jison-reducereduceconflict(master)]$ bison -v reducereduceconflictPPCR2.y
reducereduceconflictPPCR2.y: conflicts: 1 reduce/reduce
El fichero reducereduceconflictPPCR2.output queda as´ı:
[~/jison/jison-reducereduceconflict(master)]$ cat reducereduceconflictPPCR2.output
State 1 conflicts: 1 reduce/reduce
Grammar
0 $accept: def $end
1 def: param_spec return_spec ’,’
2 param_spec: type
3
| name_list ’:’ type
4 return_spec: type
5
| name ’:’ type
6 type: ID
7 name: ID
8 name_list: name
9
| name ’,’ name_list
Terminals, with rules where they appear
$end (0) 0
’,’ (44) 1 9
’:’ (58) 3 5
error (256)
ID (258) 6 7
Nonterminals, with rules where they appear
$accept (6)
on left: 0
def (7)
on left: 1, on right: 0
param_spec (8)
on left: 2 3, on right: 1
return_spec (9)
163
on left: 4 5, on right:
type (10)
on left: 6, on right: 2
name (11)
on left: 7, on right: 5
name_list (12)
on left: 8 9, on right:
1
3 4 5
8 9
3 9
state 0
0 $accept: . def $end
ID
shift, and go to state 1
def
param_spec
type
name
name_list
go
go
go
go
go
to
to
to
to
to
state
state
state
state
state
2
3
4
5
6
state 1
6 type: ID .
7 name: ID .
’,’
’,’
’:’
$default
reduce using rule 6 (type)
[reduce using rule 7 (name)]
reduce using rule 7 (name)
reduce using rule 6 (type)
state 2
0 $accept: def . $end
$end
shift, and go to state 7
state 3
1 def: param_spec . return_spec ’,’
ID
shift, and go to state 1
return_spec
type
name
go to state 8
go to state 9
go to state 10
state 4
164
2 param_spec: type .
$default
reduce using rule 2 (param_spec)
state 5
8 name_list: name .
9
| name . ’,’ name_list
’,’
shift, and go to state 11
$default
reduce using rule 8 (name_list)
state 6
3 param_spec: name_list . ’:’ type
’:’
shift, and go to state 12
state 7
0 $accept: def $end .
$default
accept
state 8
1 def: param_spec return_spec . ’,’
’,’
shift, and go to state 13
state 9
4 return_spec: type .
$default
reduce using rule 4 (return_spec)
state 10
5 return_spec: name . ’:’ type
’:’
shift, and go to state 14
state 11
9 name_list: name ’,’ . name_list
165
ID
shift, and go to state 15
name
name_list
go to state 5
go to state 16
state 12
3 param_spec: name_list ’:’ . type
ID
type
shift, and go to state 17
go to state 18
state 13
1 def: param_spec return_spec ’,’ .
$default
reduce using rule 1 (def)
state 14
5 return_spec: name ’:’ . type
ID
type
shift, and go to state 17
go to state 19
state 15
7 name: ID .
$default
reduce using rule 7 (name)
state 16
9 name_list: name ’,’ name_list .
$default
reduce using rule 9 (name_list)
state 17
6 type: ID .
$default
reduce using rule 6 (type)
166
state 18
3 param_spec: name_list ’:’ type .
$default
reduce using rule 3 (param_spec)
state 19
5 return_spec: name ’:’ type .
$default
reduce using rule 5 (return_spec)
Encuentre una gram´
atica equivalente a la anterior sin conflictos.
Soluci´
on
When the problem arises, you can often fix it by identifying the two parser states that
are being confused, and adding something to make them look distinct. In the above example, adding
one rule to return_spec as follows makes the problem go away:
%token BOGUS
...
%%
...
return_spec:
type
|
name ’:’ type
/* This rule is never used.
|
ID BOGUS
;
*/
This corrects the problem because it introduces the possibility of an additional active rule in the
context after the ID at the beginning of return_spec. This rule is not active in the corresponding
context in a param_spec, so the two contexts receive distinct parser states. As long as the token
BOGUS is never generated by yylex, the added rule cannot alter the way actual input is parsed.
In this particular example, there is another way to solve the problem: rewrite the rule for return_spec
to use ID directly instead of via name. This also causes the two confusing contexts to have different
sets of active rules, because the one for return_spec activates the altered rule for return_spec rather
than the one for name.
param_spec:
type
|
name_list ’:’ type
;
return_spec:
type
|
ID ’:’ type
;
Donde
[~/jison/jison-reducereduceconflict(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/jison/jison-reducereduceconflict
[~/jison/jison-reducereduceconflict(master)]$ git remote -v
origin [email protected]:crguezl/ull-etsii-grado-PL-reducereduce.git (fetch)
origin [email protected]:crguezl/ull-etsii-grado-PL-reducereduce.git (push)
167
https://github.com/crguezl/ull-etsii-grado-PL-reducereduce
V´
ease
V´ease Mysterious Reduce/Reduce Conflicts
5.18.
Recuperaci´
on de Errores
La recuperaci´on de errores no parece estar implementada en Jison. v´ease
la secci´
on Error Recovery de la documentaci´
on
Pullreq 5 - parser built-in grammar error recovery was completely broken
[~/srcPLgrado/jison/jison-aSb(error)]$ cat aSb.jison
%lex
%%
\s+
{}
[ab]
{ return yytext; }
.
{ return "INVALID"; }
/lex
%%
S: /* empty */ { $$ = ’’; console.log("empty"); }
| ’a’ S ’b’ { $$ = $1 + $2 + $3; console.log("S -> aSb"); }
| ’a’ S error
;
%%
parse: function parse(input) {
var self = this,
stack = [0],
vstack = [null], // semantic value stack
lstack = [], // location stack
...
recovering = 0,
TERROR = 2,
EOF = 1;
while (true) {
// retreive state number from top of stack
state = stack[stack.length - 1];
...
// handle parse error
_handle_error: if (typeof action === ’undefined’ || !action.length || !
>>
var errStr = ’’;
if (!recovering) {
5.19.
Depuraci´
on en jison
5.20.
´
Construcci´
on del Arbol
Sint´
actico
El siguiente ejemplo usa jison para construir el ´arbol sint´actico de una expresi´
on en infijo:
168
...
5.21.
Consejos a seguir al escribir un programa jison
Cuando escriba un programa jison asegurese de seguir los siguientes consejos:
1. Coloque el punto y coma de separaci´
on de reglas en una l´ınea aparte. Un punto y coma “pegado”
al final de una regla puede confundirse con un terminal de la regla.
2. Si hay una regla que produce vac´ıo, coloquela en primer lugar y acomp´
an
˜ela de un comentario
resaltando ese hecho.
3. Nunca escriba dos reglas de producci´
on en la misma l´ınea.
4. Sangre convenientemente todas las partes derechas de las reglas de producci´
on de una variable,
de modo que queden alineadas.
5. Ponga nombres representativos a sus variables sint´acticas. No llame Z a una variable que representa el concepto “lista de par´
ametros”, ll´amela ListaDeParametros.
6. Es conveniente que declare los terminales simb´olicos, esto es, aquellos que llevan un identificador
asociado. Si no llevan prioridad asociada o no es necesaria, use una declaraci´on %token. De esta
manera el lector de su programa se dar´
a cuenta r´apidamente que dichos identificadores no se
corresponden con variables sint´acticas. Por la misma raz´
on, si se trata de terminales asociados
con caracteres o cadenas no es tan necesario que los declare, a menos que, como en el ejemplo
de la calculadora para ’+’ y ’*’, sea necesario asociarles una precedencia.
7. Es importante que use la opci´
on -v para producir el fichero .output conteniendo informaci´
on
detallada sobre los conflictos y el aut´omata. Cuando haya un conflicto shift-reduce no resuelto
busque en el fichero el estado implicado y vea que LR(0) items A → α↑ y B → β↑ γ entran en
conflicto.
8. Si seg´
un el informe de jison el conflicto se produce ante un terminal a, es porque a ∈ F OLLOW (A)
y a ∈ F IRST (γ). Busque las causas por las que esto ocurre y modifique su gram´atica con vistas
a eliminar la presencia del terminal a en uno de los dos conjuntos implicados o bien establezca
reglas de prioridad entre los terminales implicados que resuelvan el conflicto.
9. N´
otese que cuando existe un conflicto de desplazamiento reducci´on entre A → α↑ y B → β↑ γ,
el programa jison contabiliza un error por cada terminal a ∈ F OLLOW (A) ∩ F IRST (γ). Por
esta raz´on, si hay 16 elementos en F OLLOW (A) ∩ F IRST (γ), el analizador jison informar´
a de
la existencia de 16 conflictos shift-reduce, cuando en realidad se trata de uno s´
olo. No desespere,
los conflictos “aut´enticos” suelen ser menos de los que jison anuncia.
10. Si necesita declarar variables globales, inicializaciones, etc. que afectan la conducta global del
analizador, escriba el c´odigo correspondiente en la cabecera del analizador, protegido por los
delimitadores %{ y %}. Estos delimitadores deber´an aparecer en una l´ınea aparte. Por ejemplo:
%{
our contador = 0;
%}
%token NUM
...
%%
169
Cap´ıtulo 6
An´
alisis Sint´
actico Ascendente en Ruby
6.1.
6.1.1.
La Calculadora
Uso desde L´ınea de Comandos
[~/src/PL/rexical/sample(master)]$ racc --help
Usage: racc [options] <input>
-o, --output-file=PATH
output file name [<input>.tab.rb]
-t, --debug
Outputs debugging parser.
-g
Equivalent to -t (obsolete).
-v, --verbose
Creates <filename>.output log file.
-O, --log-file=PATH
Log file name [<input>.output]
-e, --executable [RUBYPATH]
Makes executable parser.
-E, --embedded
Embeds Racc runtime in output.
--line-convert-all
Converts line numbers of user codes.
-l, --no-line-convert
Never convert line numbers.
-a, --no-omit-actions
Never omit actions.
--superclass=CLASSNAME
Uses CLASSNAME instead of Racc::Parser.
--runtime=FEATURE
Uses FEATURE instead of ’racc/parser’
-C, --check-only
Checks syntax and quit immediately.
-S, --output-status
Outputs internal status time to time.
-P
Enables generator profile
-D flags
Flags for Racc debugging (do not use).
--version
Prints version and quit.
--runtime-version
Prints runtime version and quit.
--copyright
Prints copyright and quit.
--help
Prints this message and quit.
[~/Dropbox/src/PL/rexical/sample(master)]$ cat -n Rakefile
1 task :default => %W{racc rex} do
2
sh "ruby calc3.tab.rb"
3 end
4
5 task :racc do
6
sh "racc calc3.racc"
7 end
8
9 task :rex do
10
sh "rex calc3.rex"
11 end
170
6.1.2.
An´
alisis L´
exico con rexical
[~/Dropbox/src/PL/rexical/sample(master)]$ cat -n calc3.rex
1 #
2 # calc3.rex
3 # lexical scanner definition for rex
4 #
5
6 class Calculator3
7 macro
8
BLANK
\s+
9
DIGIT
\d+
10 rule
11
{BLANK}
12
{DIGIT}
{ [:NUMBER, text.to_i] }
13
.|\n
{ [text, text] }
14 inner
15 end
6.1.3.
An´
alisis Sint´
actico
[~/Dropbox/src/PL/rexical/sample(master)]$ cat -n calc3.racc
1 #
2 # A simple calculator, version 3.
3 #
4
5 class Calculator3
6
prechigh
7
nonassoc UMINUS
8
left ’*’ ’/’
9
left ’+’ ’-’
10
preclow
11
options no_result_var
12 rule
13
target : exp
14
| /* none */ { 0 }
15
16
exp
: exp ’+’ exp { val[0] + val[2] }
17
| exp ’-’ exp { val[0] - val[2] }
18
| exp ’*’ exp { val[0] * val[2] }
19
| exp ’/’ exp { val[0] / val[2] }
20
| ’(’ exp ’)’ { val[1] }
21
| ’-’ NUMBER =UMINUS { -(val[1]) }
22
| NUMBER
23 end
24
25 ---- header ---26 #
27 # generated by racc
28 #
29 require ’calc3.rex’
30
31 ---- inner ---32
171
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
---- footer ---puts ’sample calc’
puts ’"q" to quit.’
calc = Calculator3.new
while true
print ’>>> ’; $stdout.flush
str = $stdin.gets.strip
break if /q/i === str
begin
p calc.scan_str(str)
rescue ParseError
puts ’parse error’
end
end
Precedencias
right is yacc’s %right, left is yacc’s %left.
= SYMBOL means yacc’s %prec SYMBOL:
prechigh
nonassoc
left
left
right
preclow
’++’
’*’ ’/’
’+’ ’-’
’=’
rule
exp: exp ’*’ exp
| exp ’-’ exp
| ’-’ exp
:
:
Atributos
=UMINUS
# equals to "%prec UMINUS"
You can use following special local variables in action.
1. result ($$)
The value of left-hand side (lhs). A default value is val[0].
2. val ($1,$2,$3...)
An array of value of right-hand side (rhs).
3. _values (...$-2,$-1,$0)
A stack of values. DO NOT MODIFY this stack unless you know what you are doing.
Declaring Tokens
By declaring tokens, you can avoid bugs.
token NUM ID IF
Opciones
You can write options for racc command in your racc file.
options OPTION OPTION ...
Options are:
172
1. omit_action_call
omit empty action call or not.
2. result_var
use/does not use local variable result”
You can use no_ prefix to invert its meanings.
User Code Block
¨
User
Code Block¨ıs a Ruby source code which is copied to output. There are three user code block,
”headerinner.and ”footer”.
Format of user code is like this:
---- header
ruby statement
ruby statement
ruby statement
---- inner
ruby statement
:
:
If four - exist on line head, racc treat it as beginning of user code block. A name of user code must
be one word.
6.2.
V´
ease Tambi´
en
Racc en GitHub
Racc User’s Manual
Martin Fowler Hello Racc
Rexical en GitHub
173
Cap´ıtulo 7
´
Transformaciones Arbol
7.1.
´
Arbol
de An´
alisis Abstracto
Un ´
arbol de an´
alisis abstracto (denotado AAA, en ingl´es abstract syntax tree o AST ) porta la
misma informaci´
on que el ´
arbol de an´
alisis sint´actico pero de forma mas condensada, elimin´
andose
terminales y producciones que no aportan informaci´
on.
´
Alfabeto con Aridad o Alfabeto Arbol
Definici´
on 7.1.1. Un alfabeto con funci´on de aridad es un par (Σ, ρ) donde Σ es un conjunto finito y ρ
es una funci´
on ρ : Σ → N0 , denominada funci´on de aridad. Denotamos por Σk = {a ∈ Σ : ρ(a) = k}.
Lenguaje de los Arboles
Definimos el lenguaje ´arbol homog´eneo B(Σ) sobre Σ inductivamente:
Todos los elementos de aridad 0 est´
an en B(Σ): a ∈ Σ0 implica a ∈ B(Σ)
Si b1 , . . . , bk ∈ B(Σ) y f ∈ Σk es un elemento k-ario, entonces f (b1 , . . . , bk ) ∈ B(Σ)
Los elementos de B(Σ) se llaman ´
arboles o t´erminos.
Ejemplo 7.1.1. Sea Σ = {A, CON S, N IL} con ρ(A) = ρ(N IL) = 0, ρ(CON S) = 2. Entonces
B(Σ) = {A, N IL, CON S(A, N IL), CON S(N IL, A), CON S(A, A), CON S(N IL, N IL), . . .}
Ejemplo 7.1.2. Una versi´
on simplificada del alfabeto con aridad en el que estan basados los a
´rboles
construidos por el compilador de Tutu es:
Σ = {ID, N U M, LEF T V ALU E, ST R, P LU S, T IM ES, ASSIGN, P RIN T }
ρ(ID) = ρ(N U M ) = ρ(LEF T V ALU E) = ρ(ST R) = 0
ρ(P RIN T ) = 1
ρ(P LU S) = ρ(T IM ES) = ρ(ASSIGN ) = 2.
Observe que los elementos en B(Σ) no necesariamente son ´
arboles “correctos”. Por ejemplo, el
arbol ASSIGN (N U M, P RIN T (ID)) es un elemento de B(Σ).
´
´
Gram´
atica Arbol
Definici´
on 7.1.2. Una gram´atica ´
arbol regular es una cuadrupla ((Σ, ρ), N, P, S), donde:
(Σ, ρ) es un alfabeto con aricidad ρ : Σ → N
N es un conjunto finito de variables sint´
acticas o no terminales
P es un conjunto finito de reglas de producci´
on de la forma X → s con X ∈ N y s ∈ B(Σ ∪ N )
S ∈ N es la variable o s´ımbolo de arranque
174
´
Lenguaje Generado por una Gram´
atica Arbol
Definici´
on 7.1.3. Dada una gram´
atica (Σ, N, P, S), se dice que un ´
arbol t ∈ B(Σ ∪ N ) es del tipo
(X1 , . . . Xk ) si el j-´esimo noterminal, contando desde la izquierda, que aparece en t es Xj ∈ N .
Si p = X → s es una producci´
on y s es de tipo (X1 , . . . Xn ), diremos que la producci´
on p es de tipo
(X1 , . . . Xn ) → X.
Definici´
on 7.1.4. Consideremos un a
´rbol t ∈ B(Σ ∪ N ) que sea del tipo (X1 , . . . Xn ), esto es las
variables sint´
acticas en el ´
arbol le´ıdas de izquierda a derecha son (X1 , . . . Xn ).
Si Xi → si ∈ P para alg´
un i, entonces decimos que el ´
arbol t deriva en un paso en el ´arbol t′
resultante de sustituir el nodo Xi por el ´
arbol si y escribiremos t =⇒ t′ . Esto es, t′ = t{Xi /si }
0
Todo ´
arbol deriva en cero pasos en si mismo t =⇒ t.
n
Decimos que un ´
arbol t deriva en n pasos en el ´
arbol t′ y escribimos t =⇒ t′ si t deriva en un
′′
paso en un ´
arbol t el cu´
al deriva en n − 1 pasos en t′ . En general, si t deriva en un cierto
∗
n´
umero de pasos en t′ escribiremos t =⇒ t′ .
Definici´
on 7.1.5. Se define el lenguaje a´rbol generado por una gram´atica G = (Σ, N, P, S) como el
∗
lenguaje L(G) = {t ∈ B(Σ) : ∃S =⇒ t}.
Ejemplo 7.1.3. Sea G = (Σ, V, P, S) con Σ = {A, CON S, N IL} y ρ(A) = ρ(N IL) = 0, ρ(CON S) =
2 y sea V = {exp, list}. El conjunto de producciones P es:
P1 = {list → N IL, list → CON S(exp, list), exp → A}
La producci´
on list → CON S(exp, list) es del tipo (exp, list) → list.
El lenguaje generado por G se obtiene realizando sustituciones sucesivas (derivando) desde el s´ımbolo de arranque hasta producir un ´
arbol cuyos nodos est´en etiquetados con elementos de Σ. En este
ejemplo, L(G) es el conjunto de arboles de la forma:
L(G) = {N IL, CON S(A, N IL), CON S(A, CON S(A, N IL)), . . .}
Ejercicio 7.1.1. Construya una derivaci´
on para el ´
arbol CON S(A, CON S(A, N IL)). ¿De que tipo
es el ´
arbol CON S(exp, CON S(A, CON S(exp, L)))?.
Cuando hablamos del AAA producido por un analizador sint´actico, estamos en realidad hablando
de un lenguaje ´
arbol cuya definici´on precisa debe hacerse a trav´es de una gram´atica ´arbol regular.
Mediante las gram´aticas ´
arbol regulares disponemos de un mecanismo para describir formalmente el
lenguaje de los AAA que producir´a el analizador sint´actico para las sentencias Tutu.
Ejemplo 7.1.4. Sea G = (Σ, V, P, S) con
Σ = {ID, N U M, LEF T V ALU E, ST R, P LU S, T IM ES, ASSIGN, P RIN T }
ρ(ID) = ρ(N U M ) = ρ(LEF T V ALU E) = ρ(ST R) = 0
ρ(P RIN T ) = 1
ρ(P LU S) = ρ(T IM ES) = ρ(ASSIGN ) = 2
V = {st, expr}
y las producciones:
P =
{
st
st
expr
expr
expr
expr
expr
}
→ ASSIGN (LEF T V ALU E, expr)
→ P RIN T (expr)
→ P LU S(expr, expr)
→ T IM ES(expr, expr)
→ NUM
→ ID
→ ST R
175
Entonces el lenguaje L(G) contiene ´
arboles como el siguiente:
ASSIGN (
LEF T V ALU E,
P LU S
(
ID,
T IM ES (
NUM,
ID
)
)
)
El cual podr´ıa corresponderse con una sentencia como a = b + 4 * c.
El lenguaje de ´
arboles descrito por esta gram´
atica ´
arbol es el lenguaje de los AAA de las sentencias
de Tutu.
Ejercicio 7.1.2. Redefina el concepto de ´
arbol de an´
alisis concreto dado en la definici´
on 5.1.7 utilizando el concepto de gram´
atica ´
arbol. Con mas precisi´
on, dada una gram´
atica G = (Σ, V, P, S) defina
una gram´
atica ´
arbol T = (Ω, N, R, U ) tal que L(T ) sea el lenguaje de los a
´rboles concretos de G.
Puesto que las partes derechas de las reglas de producci´
on de P pueden ser de distinta longitud, existe
un problema con la aricidad de los elementos de Ω. Discuta posibles soluciones.
Ejercicio 7.1.3. ¿C´
omo son los ´
arboles sint´
acticos en las derivaciones a
´rbol? Dibuje varios a
´rboles
sint´
acticos para las gram´
aticas introducidas en los ejemplos ?? y ??.
Intente dar una definici´
on formal del concepto de ´
arbol de an´
alisis sint´
actico asociado con una
derivaci´
on en una gram´
atica ´
arbol
´
Notaci´
on de Dewey o Coordenadas de un Arbol
Definici´
on 7.1.6. La notaci´
on de Dewey es una forma de especificar los sub´
arboles de un a
´rbol
t ∈ B(Σ). La notaci´
on sigue el mismo esquema que la numeraci´
on de secciones en un texto: es una
palabra formada por n´
umeros separados por puntos. As´ı t/2.1.3 denota al tercer hijo del primer hijo
del segundo hijo del ´
arbol t. La definici´
on formal ser´ıa:
t/ǫ = t
Si t = a(t1 , . . . tk ) y j ∈ {1 . . . k} y n es una cadena de n´
umeros y puntos, se define inductivamente el sub´
arbol t/j.n como el sub´
arbol n-´esimo del j-´esimo sub´
arbol de t. Esto es: t/j.n = tj /n
Ejercicio 7.1.4. Sea el ´
arbol:
t = ASSIGN
(
LEF T V ALU E,
P LU S
(
ID,
T IM ES
(
NUM,
ID
)
)
)
Calcule los sub´
arboles t/ǫ, t/2. 2. 1, t/2. 1 y t/2. 1. 2.
176
7.2.
´
Selecci´
on de C´
odigo y Gram´
aticas Arbol
La generaci´on de c´odigo es la fase en la que a partir de la Representaci´
on intermedia o IR se genera
una secuencia de instrucciones para la m´
aquina objeto. Esta tarea conlleva diversas subtareas, entre
ellas destacan tres:
La selecci´
on de instrucciones o selecci´
on de c´odigo,
La asignaci´
on de registros y
La planificaci´on de las instrucciones.
El problema de la selecci´
on de c´
odigo surge de que la mayor´ıa de las m´
aquinas suelen tener una
gran variedad de instrucciones, habitualmente cientos y muchas instrucciones admiten mas de una
decena de modos de direccionamiento. En consecuencia,
There Is More Than One Way To Do It (The Translation)
Es posible asociar una gram´
atica ´
arbol con el juego de instrucciones de una m´
aquina. Las partes
derechas de las reglas de producci´
on de esta gram´atica vienen determinadas por el conjunto de ´arboles
sint´acticos de las instrucciones. La gram´atica tiene dos variables sint´acticas que denotan dos tipos
de recursos de la m´
aquina: los registros representados por la variable sint´actica R y las direcciones
de memoria representadas por M. Una instrucci´on deja su resultado en cierto lugar, normalmente
un registro o memoria. La idea es que las variables sint´acticas en los lados izquierdos de las reglas
representan los lugares en los cuales las instrucciones dejan sus resultados.
Ademas, a cada instrucci´on le asociamos un coste:
Gram´atica Arbol Para un Juego de Instrucciones Simple
Producci´
on
Instrucci´on
R → NUM
LOADC R, NUM
R→M
LOADM R, M
M→R
STOREM M, R
R → PLUS(R,M)
PLUSM R, M
R → PLUS(R,R)
PLUSR R, R
R → TIMES(R,M)
TIMESM R, M
R → TIMES(R,R)
TIMESR R, R
R → PLUS(R,TIMES(NUM,R))
PLUSCR R, NUM, R
R → TIMES(R,TIMES(NUM,R)) TIMESCR R, NUM, R
Coste
1
3
3
3
1
6
4
4
5
Consideremos la IR consistente en el AST generado por el front-end del compilador para la expresi´on x+3*(7*y):
PLUS(M[x],TIMES(N[3],TIMES(N[7],M[y])
Construyamos una derivaci´
on a izquierdas para el ´arbol anterior:
Una derivaci´
on ´
arbol a izquierdas para
Derivaci´
on
Producci´
on
R =⇒
R → PLUS(R,R)
P (R, R) =⇒
R→M
P (M, R) =⇒
R → TIMES(R,R)
P (M, T (R, R)) =⇒
R → NUM
P (M, T (N, R)) =⇒
R → TIMES(R,R)
P (M, T (N, T (R, R))) =⇒ R → NUM
P (M, T (N, T (N, R))) =⇒ R → M
P (M, T (N, T (N, M )))
177
P (M, T (N, T (N, M )))
Instrucci´on
Coste
PLUSR R, R
1
LOADM R, M
3
TIMESR R, R
4
LOADC R, NUM
1
TIMESR R, R
4
LOADC R, NUM
1
LOADM R, M
3
Total: 17
Obs´ervese que, si asumimos por ahora que hay suficientes registros, la secuencia de instrucciones
resultante en la tercera columna de la tabla si se lee en orden inverso (esto es, si se sigue el orden de
instrucciones asociadas a las reglas de producci´
on en orden de anti-derivaci´
on) y se hace una asignaci´
on
correcta de registros nos da una traducci´on correcta de la expresi´
on x+3*(7*y):
LOADM R, M
LOADC R, NUM
TIMESR R, R
LOADC R, NUM
TIMESR R, R
LOADM R, M
PLUSR R, R
#
#
#
#
#
#
#
y
7
7*y
3
3*(7*y)
x
x+3*(7*y)
La gram´atica anterior es ambigua. El ´arbol de x+3*(7*y) puede ser generado tambi´en mediante
la siguiente derivaci´
on a izquierdas:
Otra derivaci´
on ´
arbol a izquierdas para P (M, T (N, T (N, M )))
Derivaci´
on
Producci´
on
Instrucci´on
R =⇒
R → PLUS(R,TIMES(NUM,R)) PLUSCR R, NUM, R
P (R, T (N, R)) =⇒
R→M
LOADM R, M
P (M, T (N, R)) =⇒
R → TIMES(R,M)
TIMESM R, M
P (M, T (N, T (R, M ))) R → NUM
LOADC R, NUM
P (M, T (N, T (N, M )))
Coste
4
3
6
1
Total: 14
La nueva secuencia de instrucciones para x+3*(7*y) es:
LOADC R, NUM
TIMESM R, M
LOADM R, M
PLUSCR R, NUM, R
#
#
#
#
7
7*y
x
x+3*(7*y)
Cada antiderivaci´
on a izquierdas produce una secuencia de instrucciones que es una traducci´on
legal del AST de x+3*(7*y).
El problema de la selecci´
on de c´
odigo ´
optima puede aproximarse resolviendo el problema de encontrar la derivaci´
on ´
arbol ´
optima que produce el ´
arbol de entrada (en representaci´
on intermedia IR)
Definici´
on 7.2.1. Un generador de generadores de c´odigo es una componente software que toma
como entrada una especificaci´
on de la plataforma objeto -por ejemplo mediante una gram´
atica a
´rboly genera un m´
odulo que es utilizado por el compilador. Este m´
odulo lee la representaci´
on intermedia
(habitualmente un ´
arbol) y retorna c´
odigo m´
aquina como resultado.
Un ejemplo de generador de generadores de c´odigo es iburg [7].
V´ease tambi´en el libro Automatic Code Generation Using Dynamic Programming Techniques y la
p´agina http://www.bytelabs.org/hburg.html
Ejercicio 7.2.1. Responda a las siguientes preguntas:
Sea GM la gram´
atica ´
arbol asociada segun la descripci´
on anterior con el juego de instrucciones de la m´
aquina M . Especifique formalmente las cuatro componentes de la gram´
atica
GM = (ΣM , VM , PM , SM )
¿Cual es el lenguaje ´
arbol generado por GM ?
¿A que lenguaje debe pertenecer la representaci´
on intermedia IR para que se pueda aplicar la
aproximaci´
on presentada en esta secci´
on?
178
7.3.
´
´
Patrones Arbol
y Transformaciones Arbol
Una transformaci´on de un programa puede ser descrita como un conjunto de reglas de transformaci´
on o esquema de traducci´
on ´
arbol sobre el ´arbol abstracto que representa el programa.
En su forma mas sencilla, estas reglas de transformaci´on vienen definidas por ternas (p, e, action),
donde la primera componente de la terna p es un patr´
on ´
arbol que dice que ´arboles deben ser seleccionados. La segunda componente e dice c´omo debe transformarse el ´arbol que casa con el patr´
on p.
La acci´on action indica como deben computarse los atributos del ´arbol transformado a partir de los
atributos del ´arbol que casa con el patr´
on p. Una forma de representar este esquema ser´ıa:
p =⇒ e { action }
Por ejemplo:
P LU S(N U M1 , N U M2 ) =⇒ N U M3 { $NUM_3{VAL} = $NUM_1{VAL} + $NUM_2{VAL} }
cuyo significado es que dondequiera que haya un n´odo del AAA que case con el patr´
on de entrada
P LU S(N U M, N U M ) deber´a sustituirse el sub´arbol P LU S(N U M, N U M ) por el sub´arbol N U M . Al
igual que en los esquemas de traducci´on, enumeramos las apariciones de los s´ımbolos, para distinguirlos
en la parte sem´
antica. La acci´on indica como deben recomputarse los atributos para el nuevo ´arbol:
El atributo VAL del ´
arbol resultante es la suma de los atributos VAL de los operandos en el ´arbol que
ha casado. La transformaci´on se repite hasta que se produce la normalizaci´
on del a
´rbol.
Las reglas de “casamiento” de ´
arboles pueden ser mas complejas, haciendo alusi´
on a propiedades
de los atributos, por ejemplo
ASSIGN (LEF T V ALU E, x) and { notlive($LEFTVALUE{VAL}) } =⇒ N IL
indica que se pueden eliminar aquellos ´arboles de tipo asignaci´
on en los cu´
ales la variable asociada
con el nodo LEF T V ALU E no se usa posteriormente.
Otros ejemplos con variables S1 y S2 :
IF ELSE(N U M, S1 , S2 ) and { $NUM{VAL} != 0 } =⇒ S1
IF ELSE(N U M, S1 , S2 ) and { $NUM{VAL} == 0 } =⇒ S2
Observe que en el patr´
on de entrada ASSIGN (LEF T V ALU E, x) aparece un “comod´ın”: la
variable-´
arbol x, que hace que el ´
arbol patr´on ASSIGN (LEF T V ALU E, x) case con cualquier ´
arbol
de asignaci´
on, independientemente de la forma que tenga su sub´arbol derecho.
Las siguientes definiciones formalizan una aproximaci´on simplificada al significado de los conceptos
patrones ´
arbol y casamiento de ´
arboles.
´
Patr´
on Arbol
Definici´
on 7.3.1. Sea (Σ, ρ) un alfabeto con funci´
on de aridad y un conjunto (puede ser infinito) de
variables V = {x1 , x2 , . . .}. Las variables tienen aridad cero:
ρ(x) = 0 ∀x ∈ V .
Un elemento de B(V ∪ Σ) se denomina patr´on sobre Σ.
Patr´
on Lineal
Definici´
on 7.3.2. Se dice que un patr´
on es un patr´on lineal si ninguna variable se repite.
Definici´
on 7.3.3. Se dice que un patr´
on es de tipo (x1 , . . . xk ) si las variables que aparecen en el
patr´
on leidas de izquierda a derecha en el ´
arbol son x1 , . . . xk .
179
Ejemplo 7.3.1. Sea Σ = {A, CON S, N IL} con ρ(A) = ρ(N IL) = 0, ρ(CON S) = 2 y sea V = {x}.
Los siguientes ´
arboles son ejemplos de patrones sobre Σ:
{ x, CON S(A, x), CON S(A, CON S(x, N IL)), . . .}
El patr´
on CON S(x, CON S(x, N IL)) es un ejemplo de patr´
on no lineal. La idea es que un patr´
on
lineal como ´este “fuerza” a que los ´
arboles t que casen con el patr´
on deben tener iguales los dos
correspondientes sub´
arboles t/1 y t/2. 1 situados en las posiciones de las variables 1
Ejercicio 7.3.1. Dado la gram´
atica ´
arbol:
S → S1 (a, S, b)
S → S2 (N IL)
la cu´
al genera los ´
arboles concretos para la gram´
atica
S → aSb | ǫ
¿Es S1 (a, X(N IL), b) un patr´
on ´
arbol sobre el conjunto de variables {X, Y }? ¿Lo es S1 (X, Y, a)? ¿Es
S1 (X, Y, Y ) un patr´
on ´
arbol?
Ejemplo 7.3.2. Ejemplos de patrones para el AAA definido en el ejemplo ?? para el lenguaje Tutu
son:
x, y, P LU S(x, y), ASSIGN (x, T IM ES(y, ID)), P RIN T (y) . . .
considerando el conjunto de variables V = {x, y}. El patr´
on ASSIGN (x, T IM ES(y, ID)) es del
tipo (x, y).
Sustituci´
on
Definici´
on 7.3.4. Una sustituci´
on ´
arbol es una aplicaci´
on θ que asigna variables a patrones θ : V →
B(V ∪ Σ).
Tal funci´
on puede ser naturalmente extendida de las variables a los ´
arboles: los nodos (hoja) etiquetados con dichas variables son sustituidos por los correspondientes sub´
arboles.
θ : B(V
∪ Σ) → B(V ∪ Σ)
xθ
si t = x ∈ V
tθ =
a(t1 θ, . . . , tk θ) si t = a(t1 , . . . , tk )
Obs´ervese que, al rev´es de lo que es costumbre, la aplicaci´
on de la sustituci´
on θ al patr´
on se escribe
por detr´
as: tθ.
Tambi´en se escribe tθ = t{x1 /x1 θ, . . . xk /xk θ} si las variables que aparecen en t de izquierda a
derecha son x1 , . . . xk .
Ejemplo 7.3.3. Si aplicamos la sustituci´
on θ = {x/A, y/CON S(A, N IL)} al patr´
on CON S(x, y)
obtenemos el ´
arbol CON S(A, CON S(A, N IL)). En efecto:
CON S(x, y)θ = CON S(xθ, yθ) = CON S(A, CON S(A, N IL))
Ejemplo 7.3.4. Si aplicamos la sustituci´
on θ = {x/P LU S(N U M, x), y/T IM ES(ID, N U M )} al
patr´
on P LU S(x, y) obtenemos el ´
arbol P LU S(P LU S(N U M, x), T IM ES(ID, N U M )):
P LU S(x, y)θ = P LU S(xθ, yθ) = P LU S(P LU S(N U M, x), T IM ES(ID, N U M ))
1
Repase la notaci´
on de Dewey introducida en la definici´
on ??
180
´
Casamiento Arbol
Definici´
on 7.3.5. Se dice que un patr´
on τ ∈ B(V ∪ Σ) con variables x1 , . . . xk casa con un ´
arbol
t ∈ B(Σ) si existe una sustituci´
on de τ que produce t, esto es, si existen t1 , . . . tk ∈ B(Σ) tales que
t = τ {x1 /t1 , . . . xk /tk }. Tambi´en se dice que τ casa con la sustituci´
on {x1 /t1 , . . . xk /tk }.
Ejemplo 7.3.5. El patr´
on τ = CON S(x, N IL) casa con el ´
arbol t = CON S(CON S(A, N IL), N IL)
y con el sub´
arbol t. 1. Las respectivas sustituciones son t{x/CON S(A, N IL)} y t. 1{x/A}.
t = τ {x/CON S(A, N IL)}
t. 1 = τ {x/A}
Ejercicio 7.3.2. Sea τ = P LU S(x, y) y t = T IM ES(P LU S(N U M, N U M ), T IM ES(ID, ID)).
Calcule los sub´
arboles t′ de t y las sustituciones {x/t1 , y/t2 } que hacen que τ case con t′ .
Por ejemplo es obvio que para el ´
arbol ra´ız t/ǫ no existe sustituci´
on posible:
t = T IM ES(P LU S(N U M, N U M ), T IM ES(ID, ID)) = τ {x/t1 , y/t2 } = P LU S(x, y){x/t1 , y/t2 }
ya que un t´ermino con ra´ız T IM ES nunca podr´
a ser igual a un t´ermino con ra´ız P LU S.
El problema aqu´ı es equivalente al de las expresiones regulares en el caso de los lenguajes lineales.
En aquellos, los aut´
omatas finitos nos proveen con un mecanismo para reconocer si una determinada
cadena “casa”’ o no con la expresi´
on regular. Existe un concepto an´
alogo, el de aut´
omata a
´rbol que
resuelve el problema del “casamiento” de patrones ´arbol. Al igual que el concepto de aut´omata permite
la construcci´
on de software para la b´
usqueda de cadenas y su posterior modificaci´
on, el concepto de
aut´omata ´arbol permite la construcci´
on de software para la b´
usqueda de los sub´arboles que casan con
un patr´on ´arbol dado.
´
Parse::Eyapp::TreeRegexp
Ejemplo de Transformaciones Arbol:
7.4.
Instalaci´
on
[~/jison/jison-aSb(master)]$ sudo cpan Parse::Eyapp
Donde
[~/src/perl/parse-eyapp/examples/MatchingTrees]$ pwd -P
/Users/casiano/local/src/perl/parse-eyapp/examples/MatchingTrees
Parse::Eyapp
Ejemplo de uso de Parse::Eyapp::Treeregexp
Tree Matching and Tree Substitution
Node.pm (V´ease el m´etodo s)
La gram´
atica: Expresiones
my $grammar = q{
%lexer {
m{\G\s+}gc;
m{\G([0-9]+(?:\.[0-9]+)?)}gc and return(’NUM’,$1);
m{\G([A-Za-z][A-Za-z0-9_]*)}gc and return(’VAR’,$1);
m{\G(.)}gcs and return($1,$1);
}
%right
’=’
# Lowest precedence
181
%left
%left
%left
%tree
’-’ ’+’ # + and - have
’*’ ’/’ # * and / have
NEG
# Disambiguate
# Let us build
more precedence than = Disambiguate a-b-c as (a-b)-c
more precedence than + Disambiguate a/b/c as (a/b)/c
-a-b as (-a)-b and not as -(a-b)
an abstract syntax tree ...
%%
line:
exp <%name EXPRESSION_LIST + ’;’>
{ $_[1] } /* list of expressions separated by ’;’ */
;
/* The %name directive defines the name of the
class to which the node being built belongs */
exp:
%name NUM
NUM
| %name VAR
VAR
| %name ASSIGN
VAR ’=’ exp
| %name PLUS
exp ’+’ exp
| %name MINUS
exp ’-’ exp
| %name TIMES
exp ’*’ exp
| %name DIV
exp ’/’ exp
| %name UMINUS
’-’ exp %prec NEG
| ’(’ exp ’)’
{ $_[2] } /* Let us simplify a bit the tree */
;
%%
}; # end grammar
Ejecuci´
on
El trozo de c´
odigo:
\begin{verbatim}
$parser->input(\"2*-3+b*0;--2\n");
my $t = $parser->YYParse;
# Set the input
da lugar a este ´
arbol:
[~/src/perl/parse-eyapp/examples/MatchingTrees]$ ./synopsis.pl
Syntax Tree:
EXPRESSION_LIST(
PLUS(
TIMES(
NUM( TERMINAL[2]),
UMINUS( NUM( TERMINAL[3])) # UMINUS
) # TIMES,
TIMES( VAR( TERMINAL[b]), NUM( TERMINAL[0])) # TIMES
182
) # PLUS,
UMINUS(
UMINUS( NUM( TERMINAL[2])) # UMINUS
) # UMINUS
) # EXPRESSION_LIST
Al aplicar las transformaciones:
# Let us transform the tree. Define the tree-regular expressions ..
my $p = Parse::Eyapp::Treeregexp->new( STRING => q{
{ # Example of support code
my %Op = (PLUS=>’+’, MINUS => ’-’, TIMES=>’*’, DIV => ’/’);
}
constantfold: /TIMES|PLUS|DIV|MINUS/:bin(NUM($x), NUM($y))
=> {
my $op = $Op{ref($bin)};
$x->{attr} = eval "$x->{attr} $op $y->{attr}";
$_[0] = $NUM[0];
}
uminus: UMINUS(NUM($x)) => { $x->{attr} = -$x->{attr}; $_[0] = $NUM }
zero_times_whatever: TIMES(NUM($x), .) and { $x->{attr} == 0 } => { $_[0] = $NUM }
whatever_times_zero: TIMES(., NUM($x)) and { $x->{attr} == 0 } => { $_[0] = $NUM }
},
OUTPUTFILE=> ’main.pm’
);
$p->generate(); # Create the tranformations
$t->s($uminus); # Transform UMINUS nodes
$t->s(@all);
# constant folding and mult. by zero
Obtenemos el ´arbol:
Syntax Tree after transformations:
EXPRESSION_LIST(NUM(TERMINAL[-6]),NUM(TERMINAL[2]))
synopsis.pl
[~/src/perl/parse-eyapp/examples/MatchingTrees]$ cat synopsis.pl
#!/usr/bin/perl -w
use strict;
use Parse::Eyapp;
use Parse::Eyapp::Treeregexp;
sub TERMINAL::info {
$_[0]{attr}
}
my $grammar = q{
%lexer {
m{\G\s+}gc;
m{\G([0-9]+(?:\.[0-9]+)?)}gc and return(’NUM’,$1);
m{\G([A-Za-z][A-Za-z0-9_]*)}gc and return(’VAR’,$1);
m{\G(.)}gcs and return($1,$1);
}
183
%right
%left
%left
%left
%tree
’=’
# Lowest precedence
’-’ ’+’ # + and - have more precedence than = Disambiguate a-b-c as (a-b)-c
’*’ ’/’ # * and / have more precedence than + Disambiguate a/b/c as (a/b)/c
NEG
# Disambiguate -a-b as (-a)-b and not as -(a-b)
# Let us build an abstract syntax tree ...
%%
line:
exp <%name EXPRESSION_LIST + ’;’>
{ $_[1] } /* list of expressions separated by ’;’ */
;
/* The %name directive defines the name of the
class to which the node being built belongs */
exp:
%name NUM
NUM
| %name VAR
VAR
| %name ASSIGN
VAR ’=’ exp
| %name PLUS
exp ’+’ exp
| %name MINUS
exp ’-’ exp
| %name TIMES
exp ’*’ exp
| %name DIV
exp ’/’ exp
| %name UMINUS
’-’ exp %prec NEG
| ’(’ exp ’)’
{ $_[2] } /* Let us simplify a bit the tree */
;
%%
}; # end grammar
our (@all, $uminus);
Parse::Eyapp->new_grammar( # Create the parser package/class
input=>$grammar,
classname=>’Calc’, # The name of the package containing the parser
);
my $parser = Calc->new();
# Create a parser
$parser->input(\"2*-3+b*0;--2\n");
# Set the input
my $t = $parser->YYParse;
# Parse it!
local $Parse::Eyapp::Node::INDENT=2;
print "Syntax Tree:",$t->str;
# Let us transform the tree. Define the tree-regular expressions ..
my $p = Parse::Eyapp::Treeregexp->new( STRING => q{
{ # Example of support code
184
my %Op = (PLUS=>’+’, MINUS => ’-’, TIMES=>’*’, DIV => ’/’);
}
constantfold: /TIMES|PLUS|DIV|MINUS/:bin(NUM($x), NUM($y))
=> {
my $op = $Op{ref($bin)};
$x->{attr} = eval "$x->{attr} $op $y->{attr}";
$_[0] = $NUM[0];
}
uminus: UMINUS(NUM($x)) => { $x->{attr} = -$x->{attr}; $_[0] = $NUM }
zero_times_whatever: TIMES(NUM($x), .) and { $x->{attr} == 0 } => { $_[0] = $NUM }
whatever_times_zero: TIMES(., NUM($x)) and { $x->{attr} == 0 } => { $_[0] = $NUM }
},
OUTPUTFILE=> ’main.pm’
);
$p->generate(); # Create the tranformations
$t->s($uminus); # Transform UMINUS nodes
$t->s(@all);
# constant folding and mult. by zero
local $Parse::Eyapp::Node::INDENT=0;
print "\nSyntax Tree after transformations:\n",$t->str,"\n";
El m´
etodo s
El c´odigo de s est´a en lib/Parse/Eyapp/Node.pm:
sub s {
my @patterns = @_[1..$#_];
# Make them Parse::Eyapp:YATW objects if they are CODE references
@patterns = map { ref($_) eq ’CODE’?
Parse::Eyapp::YATW->new(
PATTERN => $_,
#PATTERN_ARGS => [],
)
:
$_
}
@patterns;
my $changes;
do {
$changes = 0;
foreach (@patterns) {
$_->{CHANGES} = 0;
$_->s($_[0]);
$changes += $_->{CHANGES};
}
} while ($changes);
}
V´
ease
Parse::Eyapp
Ejemplo de uso de Parse::Eyapp::Treeregexp
185
Tree Matching and Tree Substitution
Node.pm (V´ease el m´etodo s)
7.5.
Treehugger
Donde
[~/srcPLgrado/treehugger(master)]$ pwd -P
/Users/casiano/local/src/javascript/PLgrado/treehugger
[~/srcPLgrado/treehugger(master)]$ git remote -v
origin [email protected]:crguezl/treehugger.git (fetch)
origin [email protected]:crguezl/treehugger.git (push)
https://github.com/crguezl/treehugger
learning.html
[~/srcPLgrado/treehugger(master)]$ cat learning.html
<!DOCTYPE html>
<html>
<head>
<title>treehugger.js demo</title>
<script data-main="lib/demo" src="lib/require.js"></script>
<link rel="stylesheet" href="examples/style.css" type="text/css" />
</head>
<body>
<h1>Treehugger.js playground</h1>
<table>
<tr>
<th>Javascript</th>
<th>AST</th>
</tr>
<tr>
<td><textarea id="code" rows="15" cols="42">var a = 10, b;
console.log(a, b, c);</textarea></td>
<td><textarea id="ast" rows="15" cols="42" readonly style="background-color: #eee;"></te
</tr>
<tr>
<th>Analysis code <button id="runbutton">Run</button></th>
<th>Output</th>
</tr>
<tr>
<td><textarea id="analysis" rows="15" cols="42">var declared = {console: true};
ast.traverseTopDown(
’VarDecl(x)’, function(b) {
declared[b.x.value] = true;
},
’VarDeclInit(x, _)’, function(b) {
declared[b.x.value] = true;
},
’Var(x)’, function(b) {
if(!declared[b.x.value])
186
log("Variable " + b.x.value + " is not declared.");
}
);
</textarea></td>
<td><textarea id="output" rows="15" cols="42" readonly style="background-color: #eee;"><
</tr>
</table>
</body>
</html>
lib/demo.js
[~/srcPLgrado/treehugger(master)]$ cat lib/demo.js
require({ baseUrl: "lib" },
["treehugger/tree",
"treehugger/traverse",
"treehugger/js/parse",
"jquery",
"treehugger/js/acorn", // Acorn is a JavaScript parser
"treehugger/js/acorn_loose" // This module provides an alternative
// parser with the same interface as
// ‘parse‘, but will try to parse
// anything as JavaScript, repairing
// syntax error the best it can.
], function(tree, traverse, parsejs, jq, acorn, acorn_loose) {
window.acorn_loose = acorn_loose
function log(message) {
$("#output").val($("#output").val() + message + "\n");
}
function exec() {
var js = $("#code").val();
var analysisJs = $("#analysis").val();
$("#output").val("");
// https://developer.mozilla.org/en-US/docs/Web/API/Performance.now()
var t = performance.now();
var ast = parsejs.parse(js);
t -= performance.now();
$("#ast").val(t + "\n" + ast.toPrettyString());
try {
eval(analysisJs);
} catch(e) {
$("#output").val("JS Error");
console.log(e.message)
}
}
tree.Node.prototype.log = function() {
$("#output").val(this.toPrettyString());
}
require.ready(function() {
187
$("#code").keyup(exec);
$("#runbutton").click(exec);
exec();
});
}
);
V´
ease
treehugger.js is a Javascript library for program processing. It has generic means to represent and manipula
You can see treehugger.js in action in this simple demo.
Avoiding JavaScript Pitfalls Through Tree Hugging YouTube. Slides.
AST traversal javascript libraries
RequireJS
7.6.
´
Pr´
actica: Transformaciones en Los Arboles
del Analizador PL0
´
Partimos del c´odigo realizado en la pr´actica An´
alisis de Ambito
en PL0 5.7.
Modifique el ´
arbol generado por el c´odigo de esa pr´actica usando las transformaciones de constant
folding o plegado de las constantes:
P LU S(N U M1 , N U M2 ) =⇒ N U M3 { $NUM_3{VAL} = $NUM_1{VAL} + $NUM_2{VAL} } M IN U S(N U M1 , N U
N U M3 { $NUM_3{VAL} = $NUM_1{VAL} - $NUM_2{VAL} } T IM ES(N U M1 , N U M2 ) =⇒ N U M3 { $NUM_3{VAL}
DIV (N U M1 , N U M2 ) =⇒ N U M3 { $NUM_3{VAL} = $NUM_1{VAL} / $NUM_2{VAL} }
etc.
Opcionalmente si lo desea puede considerar otras transformaciones: T IM ES(X, N U M2 ) and
{ $NUM_2{VAL} = 2s para alg´
un s } =⇒ SHIF T LEF T (X; N U M3 ) { $NUM_3{VAL} = s }
188
Parte II
PARTE: CREATE YOUR OWN
PROGRAMMING LANGUAGE
189
A course by Nathan Whitehead.
Nathan Whitehead en YouTube
Repositorios relacionados:
https://github.com/crguezl/nathanuniversityexercisesPL
190
Cap´ıtulo 8
JavaScript Review
http://nathansuniversity.com/jsreview.html
8.1.
Closures
http://nathansjslessons.appspot.com/
191
Cap´ıtulo 9
Your First Compiler
http://nathansuniversity.com/music.html
192
Cap´ıtulo 10
Parsing
http://nathansuniversity.com/pegs.html
193
Cap´ıtulo 11
Scheem Interpreter
http://nathansuniversity.com/scheem.html
11.1.
Scheem Interpreter
11.2.
Variables
11.3.
Setting Values
11.4.
Putting Things Together
11.4.1.
Unit Testing: Mocha
Introducci´
on
Mocha is a feature-rich JavaScript test framework running on node.js and the browser, making
asynchronous testing simple and fun. Mocha tests run serially, allowing for flexible and accurate
reporting, while mapping uncaught exceptions to the correct test cases.
http://mochajs.org/
https://github.com/visionmedia/mocha
• An example setup for unit testing JavaScript in the browser with the Mocha testing framework and Chai assertions: https://github.com/ludovicofischer/mocha-chai-browser-demo
• Karma - a test runner
mocha init
[~/srcPLgrado/mocha-chai-browser-demo(master)]$ mocha --help
Usage: _mocha [debug] [options] [files]
Commands:
init <path>
initialize a client-side mocha setup at <path>
Options:
-h,
-V,
-r,
-R,
--help
--version
--require <name>
--reporter <name>
output usage information
output the version number
require the given module
specify the reporter to use
194
-u, --ui <name>
-g, --grep <pattern>
-i, --invert
-t, --timeout <ms>
-s, --slow <ms>
-w, --watch
-c, --colors
-C, --no-colors
-G, --growl
-d, --debug
-b, --bail
-A, --async-only
-S, --sort
--recursive
--debug-brk
--globals <names>
--check-leaks
--interfaces
--reporters
--compilers <ext>:<module>,...
--inline-diffs
--no-exit
specify user-interface (bdd|tdd|exports)
only run tests matching <pattern>
inverts --grep matches
set test-case timeout in milliseconds [2000]
"slow" test threshold in milliseconds [75]
watch files for changes
force enabling of colors
force disabling of colors
enable growl notification support
enable node’s debugger, synonym for node --debug
bail after first test failure
force all tests to take a callback (async)
sort test files
include sub directories
enable node’s debugger breaking on the first line
allow the given comma-delimited global [names]
check for global variable leaks
display available interfaces
display available reporters
use the given module(s) to compile files
display actual/expected differences inline within each str
require a clean shutdown of the event loop: mocha will not
[~/srcPLgrado]$ mocha init chuchu
[~/srcPLgrado]$ ls -ltr
total 16
....
drwxr-xr-x
6 casiano staff 204 20 ene 11:16 chuchu
[~/srcPLgrado]$ tree chuchu/
chuchu/
|-- index.html
|-- mocha.css
|-- mocha.js
‘-- tests.js
[~/srcPLgrado/mocha-tutorial]$ cat test/test.js
var assert = require("assert")
describe(’Array’, function(){
describe(’#indexOf()’, function(){
it(’should return -1 when the value is not present’, function(){
assert.equal(-1, [1,2,3].indexOf(5));
assert.equal(-1, [1,2,3].indexOf(0));
assert.equal( 0, [1,2,3].indexOf(99));
})
})
})
[~/srcPLgrado/mocha-tutorial]$ mocha
.
0 passing (5ms)
1 failing
1) Array #indexOf() should return -1 when the value is not present:
AssertionError: 0 == -1
at Context.<anonymous> (/Users/casiano/local/src/javascript/PLgrado/mocha-tutorial/test/t
195
Mocha allows you to use any assertion library you want, if it throws an error, it will work! This
means you can utilize libraries such as should.js, node’s regular assert module, or others.
Browser support
Mocha runs in the browser.
Every release of Mocha will have new builds of ./mocha.js and ./mocha.css for use in the
browser.
To setup Mocha for browser use all you have to do is include the script, stylesheet,
Tell Mocha which interface you wish to use, and then
Run the tests.
A typical setup might look something like the following, where we call mocha.setup(’bdd’) to use
the BDD interface before loading the test scripts, running them onload with mocha.run().
<html>
<head>
<meta charset="utf-8">
<title>Mocha Tests</title>
<link rel="stylesheet" href="mocha.css" />
</head>
<body>
<div id="mocha"></div>
<script src="jquery.js"></script>
<script src="expect.js"></script>
<script src="mocha.js"></script>
<script>mocha.setup(’bdd’)</script>
<script src="test.array.js"></script>
<script src="test.object.js"></script>
<script src="test.xhr.js"></script>
<script>
mocha.checkLeaks();
mocha.globals([’jQuery’]);
mocha.run();
</script>
</body>
</html>
Mocha ¨ınterface”system allows developers to choose their style of DSL. Shipping with BDD,
TDD, and exports flavoured interfaces.
mocha.globals([names ...])
A list of accepted global variable names. For example, suppose your app deliberately exposes a
global named app and YUI
mocha.checkLeaks()
By default Mocha will not check for global variables leaked while running tests
196
TDD
The Mocha TDD interface provides suite(), test(), setup(), and teardown().
suite(’Array’, function(){
setup(function(){
// ...
});
suite(’#indexOf()’, function(){
test(’should return -1 when not present’, function(){
assert.equal(-1, [1,2,3].indexOf(4));
});
});
});
V´
ease
https://github.com/crguezl/nathanuniversityexercisesPL/tree/master/scheem8
11.4.2.
Grunt
http://gruntjs.com/getting-started
npm install -g grunt-cli
A typical setup will involve adding two files to your project: package.json and the Gruntfile.
package.json: This file is used by npm to store metadata for projects published as npm modules.
You will list grunt and the Grunt plugins your project needs as devDependencies in this file.
Gruntfile: This file is named Gruntfile.js or Gruntfile.coffee and is used to configure or
define tasks and load Grunt plugins.
package.json
The package.json file belongs in the root directory of your project, next to the Gruntfile, and
should be committed with your project source.
Running npm install in the same folder as a package.json file will install the correct version of
each dependency listed therein.
There are a few ways to create a package.json file for your project:
• Most grunt-init templates will automatically create a project-specific package.json file.
• The npm init command will create a basic package.json file.
• Start with the example below, and expand as needed, following this specification.
{
"name": "my-project-name",
"version": "0.1.0",
"devDependencies": {
"grunt": "~0.4.2",
"grunt-contrib-jshint": "~0.6.3",
"grunt-contrib-nodeunit": "~0.2.0",
"grunt-contrib-uglify": "~0.2.2"
}
}
197
Gruntfile
The Gruntfile.js or Gruntfile.coffee file is a valid JavaScript or CoffeeScript file that belongs in
the root directory of your project, next to the package.json file, and should be committed with your
project source.
A Gruntfile is comprised of the following parts:
The ”wrapper”function
Project and task configuration
Loading Grunt plugins and tasks
Custom tasks
An example Gruntfile
In the following Gruntfile, project metadata is imported into the Grunt config from the project’s
package.json file and the
grunt-contrib-uglify
plugin’s uglify task is configured to minify a source file and generate a banner comment dynamically
using that metadata.
When grunt is run on the command line, the uglify task will be run by default.
module.exports = function(grunt) {
// Project configuration.
grunt.initConfig({
pkg: grunt.file.readJSON(’package.json’),
uglify: {
options: {
banner: ’/*! <%= pkg.name %> <%= grunt.template.today("yyyy-mm-dd") %> */\n’
},
build: {
src: ’src/<%= pkg.name %>.js’,
dest: ’build/<%= pkg.name %>.min.js’
}
}
});
// Load the plugin that provides the "uglify" task.
grunt.loadNpmTasks(’grunt-contrib-uglify’);
// Default task(s).
grunt.registerTask(’default’, [’uglify’]);
};
Now that you’ve seen the whole Gruntfile, let’s look at its component parts.
The ”wrapper”function
Every Gruntfile (and gruntplugin) uses this basic format, and all of your Grunt code must be
specified inside this function:
module.exports = function(grunt) {
// Do grunt-related things in here
};
198
Project and task configuration
Most Grunt tasks rely on configuration data defined in an object passed to the grunt.initConfig
method.
In this example, grunt.file.readJSON(’package.json’) imports the JSON metadata stored
in package.json into the grunt config. Because <% %> template strings may reference any config
properties, configuration data like filepaths and file lists may be specified this way to reduce repetition.
You may store any arbitrary data inside of the configuration object, and as long as it doesn’t conflict
with properties your tasks require, it will be otherwise ignored. Also, because this is JavaScript, you’re
not limited to JSON; you may use any valid JS here. You can even programmatically generate the
configuration if necessary.
Like most tasks, the grunt-contrib-uglify plugin’s uglify task expects its configuration to be
specified in a property of the same name. Here, the banner option is specified, along with a single
uglify target named build that minifies a single source file to a single destination file.
// Project configuration.
grunt.initConfig({
pkg: grunt.file.readJSON(’package.json’),
uglify: {
options: {
banner: ’/*! <%= pkg.name %> <%= grunt.template.today("yyyy-mm-dd") %> */\n’
},
build: {
src: ’src/<%= pkg.name %>.js’,
dest: ’build/<%= pkg.name %>.min.js’
}
}
});
A simple Grunt.js example
https://github.com/UWMadisonUcomm/grunt-simple-example
[~/srcPLgrado/grunt-simple-example(master)]$ pwd
/Users/casiano/srcPLgrado/grunt-simple-example
[~/srcPLgrado/grunt-simple-example(master)]$ git remote -v
origin [email protected]:UWMadisonUcomm/grunt-simple-example.git (fetch)
origin [email protected]:UWMadisonUcomm/grunt-simple-example.git (push)
[~/srcPLgrado/grunt-simple-example(master)]$ ls
Gruntfile.js Readme.md
assets
index.html
node_modules package.json src
[~/srcPLgrado/grunt-simple-example(master)]$ cat Gruntfile.js
module.exports = function(grunt){
grunt.initConfig({
uglify: {
main: {
files: {
’assets/app.min.js’: [
’src/javascripts/jquery-1.10.2.min.js’,
’src/javascripts/bootstrap.js’,
’src/javascripts/application.js’
]
}
}
},
less: {
199
application: {
options: {
yuicompress: true
},
files: {
"assets/app.min.css": "src/stylesheets/application.less"
}
}
},
watch: {
javascripts: {
files: [’src/javascripts/**/*’],
tasks: [’uglify’]
},
stylesheets: {
files: [’src/stylesheets/**/*’],
tasks: [’less’]
}
}
});
// Load plugins
grunt.loadNpmTasks(’grunt-contrib-less’);
grunt.loadNpmTasks(’grunt-contrib-uglify’);
grunt.loadNpmTasks(’grunt-contrib-watch’);
// Register tasks
grunt.registerTask(’default’, [’uglify’, ’less’]);
}
[~/srcPLgrado/grunt-simple-example(master)]$ cat package.json
{
"name": "grunt-simple-example",
"version": "0.0.1",
"main": "index.js",
"devDependencies": {
"grunt": "~0.4.1",
"grunt-contrib-cssmin": "~0.6.2",
"grunt-contrib-less": "~0.7.0",
"grunt-contrib-uglify": "~0.2.4",
"grunt-contrib-watch": "~0.5.3"
},
"author": "Bryan Shelton",
"license": "BSD-2-Clause"
}
[~/srcPLgrado/grunt-simple-example(master)]$ npm install
npm WARN package.json [email protected] No repository field.
[~/srcPLgrado/grunt-simple-example(master)]$
[~/srcPLgrado/grunt-simple-example(master)]$ grunt watch
Running "watch" task
Waiting...OK
200
>> File "src/javascripts/application.js" changed.
Running "uglify:main" (uglify) task
File "assets/app.min.js" created.
Done, without errors.
Completed in 3.897s at Mon Jan 20 2014 19:02:03 GMT+0000 (WET) - Waiting...
11.4.3.
GitHub Project Pages
Project Pages are kept in the same repository as the project they are for.
These pages are similar to User and Org Pages, with a few slight differences:
The gh-pages branch is used to build and publish from.
A custom domain on user/org pages will apply the same domain redirect to all project pages
hosted under that account, unless the project pages use their own custom domain.
If no custom domain is used, the project pages are served under a subpath of the user pages:
username.github.io/projectname
Por ejemplo, mi usuario es crguezl. Si el proyecto se llama nathanuniversityexercisesPL, la
direcci´on ser´a:
http://crguezl.github.io/nathanuniversityexercisesPL/
Custom 404s will only work if a custom domain is used, otherwise the User Pages 404 is used.
Creating Project Pages manually
1. Setting up Pages on a project requires a new .orphan”branch in your repository. The safest way
to do this is to start with a fresh clone.
git clone https://github.com/user/repository.git
# Clone our repository
# Cloning into ’repository’...
remote: Counting objects: 2791, done.
remote: Compressing objects: 100% (1225/1225), done.
remote: Total 2791 (delta 1722), reused 2513 (delta 1493)
Receiving objects: 100% (2791/2791), 3.77 MiB | 969 KiB/s, done.
Resolving deltas: 100% (1722/1722), done.
2. Now that we have a clean repository, we need to create the new branch and remove all content
from the working directory and index.
cd repository
git checkout --orphan gh-pages
# Creates our branch, without any parents (it’s an orphan!)
# Switched to a new branch ’gh-pages’
git rm -rf .
# Remove all files from the old working tree
# rm ’.gitignore’
201
3. Now we have an empty working directory. We can create some content in this branch and push
it to GitHub. For example:
echo "My GitHub Page" > index.html
git add index.html
git commit -a -m "First pages commit"
git push origin gh-pages
202
Cap´ıtulo 12
Functions and all that
http://nathansuniversity.com/funcs.html
203
Cap´ıtulo 13
Inventing a language for turtle graphics
http://nathansuniversity.com/turtle.html
204
Parte III
PARTE: HERRAMIENTAS
205
´Indice general
206
´Indice de figuras
207
´Indice de cuadros
208
´Indice alfab´
etico
Content, 15
CSS, 11
CSS reset document, 14
a´rbol de an´
alisis abstracto, 174
´arbol de an´
alisis sint´actico concreto, 73
´arbol sint´actico concreto, 71, 111
´arboles, 174
AAA, 174
abstract syntax tree, 174
access link, 135
acci´on de reducci´
on, 125
acciones de desplazamiento, 125
acciones sem´
anticas, 78
acciones shift, 125
alfabeto con funci´on de aridad, 174
algoritmo de construcci´
on del subconjunto, 124
antiderivaci´
on, 120
assert style, 22
AST, 174
atributo heredado, 155, 159
atributo sintetizado, 78, 155, 159
atributos formales, 158
atributos heredados, 155, 156, 159
atributos intr´ınsecos, 159
atributos sintetizados, 155, 159
aut´omata ´arbol, 181
aut´omata finito determinista, 124
aut´omata finito no determinista con ǫ-transiciones,
122
BDD, 21
block, 16
Border, 15
box model, 15
bubble phase, 62
declaration, 12
declaration block, 12
definici´on dirigida por la sint´axis, 158
deriva en un paso en el ´arbol, 175
devDependencies, 197
DFA, 124
DOM storage, 49
Ejercicio
Recorrido del ´arbol en un ADPR, 77
esquema de traducci´on, 78, 154
esquema de traducci´on ´arbol, 179
evaluation stack, 135
expect interface, 22
favicon, 53
Favorite icon, 53
funci´on de aridad, 174
funci´on de transici´on del aut´omata, 124
generador de generadores de c´odigo, 178
goto, 125
grafo de dependencias, 159
gram´atica ´arbol regular, 174
gram´atica atribu´ıda, 159
gram´atica es recursiva por la izquierda, 77, 92
handle, 121
INI, 60
inline, 16
IR, 177
items n´
ucleo, 129
callback, 40
capture phase, 62
casa con la sustituci´
on, 181
casa con un ´arbol, 181
casamiento de ´arboles, 179
Cascading Style Sheets, 11
Chai should, 22
clausura, 124
conflicto de desplazamiento-reducci´
on, 126, 149
conflicto reduce-reduce, 126, 149
conflicto shift-reduce, 126, 149
constant folding, 188
JavaScript Object Notation, 45
jQuery, 37
JSON, 45
Karma, 26
L-atribu´ıda, 159
LALR, 127
lenguaje ´arbol generado por una gram´atica, 175
lenguaje ´arbol homog´eneo, 174
209
recursiva por la derecha, 100
recursiva por la izquierda, 78, 92
recursive descent parser, 85
reducci´on por defecto, 141
reducci´on-reducci´
on, 126, 149
reentrant, 135
register spilling, 135
reglas de evaluaci´on de los atributos, 158
reglas de transformaci´on, 179
reglas sem´
anticas, 158
Representaci´
on intermedia, 177
rightmost derivation, 120
rule set, 12
lenguaje de las formas sentenciales a rderechas,
121
local storage, 49
LR, 120
manecilla, 121
mango, 121
Margin, 15
Mocha TDD interface, 197
NFA, 122
normalizaci´on del ´
arbol, 179
orden parcial, 159
orden topol´ogico, 159
Padding, 15
parsing expression, 84
parsing expression grammar, 84
patr´on, 179
patr´on ´arbol, 179
patr´on de entrada, 179
patr´on lineal, 179
patrones ´arbol, 179
pattern matching, 50
PEG, 84
plegado de las constantes, 188
Pr´actica
Ambiguedad en C++, 107
´
An´
alisis de Ambito
en PL0, 131
Analizador de PL0 Ampliado Usando PEG.js,
107
Analizador de PL0 Usando Jison, 130
Analizador Descendente Predictivo Recursivo, 79
Analizador L´exico para Un Subconjunto de
JavaScript, 68
´
Calculadora con An´
alisis de Ambito,
133
Calculadora con Funciones, 132
Calculadora con Listas de Expresiones y Variables, 120
Comma Separated Values. CSV, 32
Conversor de Temperaturas, 9
Ficheros INI, 60
Inventando un Lenguaje: Tortoise, 109
Palabras Repetidas, 56
Secuencia de Asignaciones Simples, 115
Traducci´on de Infijo a Postfijo, 132
´
Transformaciones en Los Arboles
del Analizador PL0, 188
Primeros, 123
property, 12
pseudo-clase, 14
recursion, 135
210
S-atribu´ıda, 159
selecci´
on de c´odigo, 177
selector, 12
session storage, 49
shortcut, 53
shorthand property, 15
siguientes, 123
SLR, 125, 126
static link, 135
sustituci´
on ´arbol, 180
t´erminos, 174
tabla de acciones, 125
tabla de gotos, 125
tabla de saltos, 125
target phase, 62
task runner, 23
text area, 48
value, 12
Web storage, 49
Bibliograf´ıa
[1] Mark Pilgrim. Dive into HTML5. http://diveinto.html5doctor.com/index.html, 2013.
[2] G. Wilson and A. Oram. Beautiful Code: Leading Programmers Explain How They Think. O’Reilly
Media, 2008.
[3] Nathan Whitehead. Create Your Own Programming Language. http://nathansuniversity.com/.
2012.
[4] Nathan Whitehead. What’s a Closure?. http://nathansjslessons.appspot.com/. 2012.
[5] Steven S. Muchnick. Advanced compiler design and implementation. Morgan Kaufmann Publishers
Inc., San Francisco, CA, USA, 1997.
[6] T. Mogensen and T.A. Mogensen. Introduction to compiler design. Undergraduate topics in
computer science. Springer London, Limited, 2011.
[7] Todd A. Proebsting. Burg, iburg, wburg, gburg: so many trees to rewrite, so little time (invited
talk). In ACM SIGPLAN Workshop on Rule-Based Programming, pages 53–54, 2002.
211