Enlazando la entrada de Bison con Flex (muy básico) forGeeks

Como me falta mucho mucho mucho mucho mucho mucho estudio (mucho) para usar Bison y Flex a la perfección, pues solamente pondré lo que yo he comprendido, ejemplificandolo con la práctica que nos puso el profesor (un indentador).

Primero, usando Bison. Antes que nada, deberían de dar un "man bison" o "info bison" para checar las especificaciones de la herramienta.

Como deberíamos saber (para el que no lo sepa: RTFM), la estructura de una gramática para YACC/BISON, es:

/*----------------------------------------------------------------------------------------------------------------*/
%{
/*declaraciones en C*/
%}
/*Definiciones de Bison*/
%%
/*Gramática*/
%%
/*Código auxiliar en C*/
/*----------------------------------------------------------------------------------------------------------------*/

Ahora, modelemos la gramática para el lenguaje que genera expresiones de la forma:

hola{mundo{cruel}}
hola{}
.
.
.

La gramática a la que llegamos fué:

S-> IS
S-> {S}
S-> I
I-> cadena
I-> epsilon

Codificamos esa gramática para Bison:

S: I S {printf("Regla 1");}
| CORI S CORD {printf("Regla 2");}
| I {printf("Regla 3");}
;

I: CADENA {printf("Regla 4");}
| /*vacio*/ {printf("Regla 5");}
;

Aquí, los printf se ejecutarán cada vez que el analizador sintáctico compruebe que se está utilizando esa producción. El archivo quedaría hasta el momento:

/*----------------------------------------------------------------------------------------------------------------*/

/*indentador.y*/

%{
#include<'stdio.h>
%}
%token CADENA CORI CORD /*CORI = '{' CORD='}'*/
%start S /*Le decimos a bison cual es nuestro simbolo inicial*/
%%
S: I S {printf("Regla 1");}
| CORI S CORD {printf("Regla 2");}
| I {printf("Regla 3");}
;

I: CADENA {printf("Regla 4");}
| /*vacio*/ {printf("Regla 5");}
;
%%
main(){
yyparse(); /*ejecuta el analizador sintáctico*/
}

/*----------------------------------------------------------------------------------------------------------------*/

Bueno, si recordamos, podemos accesar a los valores semánticos de Bison con pseudo variables. Digamos que en la regla I: CADENA quisieramos saber el valor de CADENA. Como CADENA está en la posición 1, podemos decir que cadena es la variable $1. Entonces, pudieramos hacer:

I: CADENA {printf("Se esta recibiendo la cadena: %s",$1);}
/*{$$=$1} asignaría a I el valor de CADENA*/

Lo que nos tendría que regresar el valor semánticode cadena. El problema con esto, es que las pseudo variables están declaradas como entero, es decir, espera que CADENA tenga un valo entero (y nosotros estamos pidiendole que imprima un tipo char*). Tambien esperaríamos que CORI(D) sea un caracter. Para definir el tipo que recibirán CADENA y CORI(D), declaramos una %union.

%union{
char caracter;
char *cadena;
}

y le decimos en las definiciones que tipo de valor deben tener los símbolos no terminales:

%token <'caracter> CORI CORD
%token <'cadena> CADENA

y los símbolos terminales de los cuales pretendamos saber el valor semántico:

%type <'cadena> S
%type <'cadena> I

con lo que la gramática quedaría:

/*----------------------------------------------------------------------------------------------------------------*/

/*indentador.y*/

%{
#include <'stdio.h>
%}

%union{
char caracter;
char *cadena;
}

%token <'caracter> CORI CORD
%token <'cadena> CADENA
%type <'cadena> S
%type <'cadena> I
%start S
%%
S: I S {printf("Regla 1");}
| CORI S CORD {printf("Regla 2");}
| I {printf("Regla 3");}
;

I: CADENA {printf("Regla 4 nos da la cadena: %s",$1);}
| /*vacio*/ {printf("Regla 5");}
;
%%
main(){
yyparse(); /*ejecuta el analizador sintáctico*/
}

/*----------------------------------------------------------------------------------------------------------------*/

Finalmente, un problema con la gramática. Como la entrada desde el teclado, recibirá cadenas que terminan con el fin de linea (\n), entonces necesitamos poner una regla de producción que contemple el fin de linea como parte del lenguaje. Declararemos NL como un símbolo terminal (\n) y añadiremos la siguiente producción:

INICIO: INICIO NL S
| S
;

Así, la gramática final sería:

/*----------------------------------------------------------------------------------------------------------------*/

/*indentador.y*/

%{
#include ...<'stdio.h>
%}

%union{
char caracter;
char *cadena;
}

%token <'caracter> CORI CORD NL
%token <'cadena> CADENA
%type <'cadena> S
%type <'cadena> I
%start INICIO
%%
INICIO: INICIO NL S {printf("Regla con NL");}
| S {printf("Regla sin NL");}
;
S: I S {printf("Regla 1");}
| CORI S CORD {printf("Regla 2");}
| I {printf("Regla 3");}
;

I: CADENA {printf("Regla 4 nos da la cadena: %s",$1);}
| /*vacio*/ {printf("Regla 5");}
;
%%
main(){
yyparse(); /*ejecuta el analizador sintáctico*/
}

/*----------------------------------------------------------------------------------------------------------------*/

Ahora, la entrada con Flex. Ya saben, "man flex" o "info flex".

La estructura de un archivo para crear analizadores léxicos, es esta:

/*----------------------------------------------------------------------------------------------------------------*/
%{
/*Se hacen definiciones, se llaman librerias, etc.*/
%}
/*Se definen los conjuntos que se usarán en las expresiones regulares, por ejemplo*/
%%
/*Aquí se ponen las expresiones regulares que el analizador léxico va a reconocer, y la acción que llevará acabo cuando reconozca los tokens*/
%%
/*Código en C. Aquí se pone el main (si lo tiene), o cualquier código auxiliar que se necesite.*/

/*----------------------------------------------------------------------------------------------------------------*/

Como Flex dará la entrada para Bison, no tenemos que preocuparnos por poner un main (el main está en Bison), solo necesitamos las expresiones regulares que reconocerá.

Declaramos un "y.tab.h" que Bison usará para enlazarse. Se creará al compilarlo.

Para cada expresión que reconozcamos (y que Bison use), tendremos que poner un return seguido del nombre del token (como nosotros lo nombramos en la gramática).

La estructura %union en Bison, al compilarla se convierte en una estructura yylval. Para asignarle la cadena que queremos a la pseudo variable, necesitamos pasarle a la estructura yylval el valor que hay en yytext (que es donde Flex guarda momentaneamente el valor de la cadena reconocida). Una vez pasado a la pseudo variable, podemos decirle que regrese el token deseado (en este ejemplo, CADENA, NL, CORI, CORD). Por ejemplo, para regresar un salto de linea {yylval.caracter='\n'; return NL;}

/*----------------------------------------------------------------------------------------------------------------*/
/*indentador.l*/
%{
#include <'stdio.h>
#include "y.tab.h"
%}

SIM [a-zA-Z][a-zA-Z0-9]*
CAD {SIM}({SIM})*

%%
{CAD} {yylval.cadena=(char *)malloc(255*sizeof(char));strcpy(yylval.cadena,yytext);return (CADENA);}
"{" {yylval.caracter='{';return (CORI);}
"}" {yylval.caracter='}';return (CORD);}
\n {yylval.caracter='\n';return (NL);}
. ECHO;
%%

/*----------------------------------------------------------------------------------------------------------------*/

Finalmente, para compilar:

bison -yd indentador.y
flex indentador.l
gcc y.tab.c lex.yy.c -ll -ly -o salida

Para ejecutar:
./salida

Bueno, eso es todo, espero que les sirva para iniciar al menos. Cualquier duda, o siguen mi consejo (RTFM!!!) o se la guardan, porque no la voy a contestar. Va, ahí luego.

Actualización:

Los archivos:

ejemplo.tar.gz

make
make run

Intenten con cadenas hola{mundo{cruel}} y así. No está completo, falta que imprima las llaves, pero ahí está.

Como Instalar XMMS en Ubuntu Dapper for Geeks

Esta vez, mostraré como instalar XMMS en Ubuntu.

1. En linea de comandos:
sudo apt-get install xmms xmms-skins

2. Ejecutar xmms desde Aplicaciones->Sonido y Video

Para que aparezca la canción en tu nickname de aMSN:

1. En linea de comandos:
wget http://surfnet.dl.sourceforge.net/sourceforge/amsn/music-1.3.zip

ó bajar el plugin Music de la página de aMSN.

2. En linea de comandos:
sudo apt-get install xmms-infopipe

esto baja un plugin para que haya comunicacion entre XMMS y aMSN.

3. En XMMS, Opciones->Preferencias->Plugins Generales, habilitar el plugin InfoPipe.
4. En aMSN, Archivo->Selector de Plugins, habilitar el plugin Music y en configurar, seleccionar XMMS.
5. Escuchar tu playlist.

Para obtener las preconfiguraciones del ecualizador:

1. Bajar paquete:
http://www.xmms.org/misc/winamp_presets.gz

2. En la carpeta donde está el archivo bajado, hacer:
gunzip -c winamp_presets.gz > ~/.xmms/eq.preset

3. Iniciar XMMS, y en el EQ seleccionar Cargar->Preconfigurado. (NO OLVIDAR QUE EL EQ DEBE ESTAR "ENCENDIDO").

En Synaptic hay bastantes plugins que pueden ser descargados directamente (sin necesidad de compilarlos), así que es cuestión de buscar lo que queramos.

Por si no encuentran lo que buscan de su reproductor de música: http://www.xmms.org

FLISOL 2007

Si tu de alguna forma estas viendo este anuncio, tal vez formes parte de la ESCOM, te gusten los temas relacionados en este blog con la computacion o de alguna bendita forma pierdes el tiempo con tu compu visitando lugares en internet, el punto es que usas una computadora en tiempos de ocio largos y la computacion tiene aunque sea un poco que ver contigo, bueno ps esta invitacion es justo para ti!!!. (hago una transcripcion del flyer originial).

Flisol 2007 MEXICO
Festival Latinoamericano de instalacion de software libre

Sabado 28 de Abril , Registro 8:00 a.m.

Trae tu computadora y te instalaremos software libre sin licencias restricitivas y caras, desde un sistema operativo GNU/Linux o BSD hasta aplicaciones libres para Windows o Mac. Ademas asiste a las platicas sobre el uso de Software Libre en diversos campos.

Ademas te llevaras gratis un CD con el software que se te haya instalado. !!! LA ENTRADA TAMBIEN ES LIBRE !!!.
Av. Juan de Dios Batiz S/N. Casi esquina con Miguel Othon de Mendizabal, Unidad Profesional "Adolfo Lopez Mateos". (Zacatenco, enfrente de Plaza Torres, atras de Metro Politecnico).

El preregistro para asistir y mas informacion sobre horarios y actividades en http://www.escom.ipn.mx/flisol , http://flisolmexico.info o http://installfest.info.

Asi que ya saben, esperamos su asistencia al evento que se celebrara en Mexico, existen cuatro sedes, vocacional #9, UNAM (C.U.), Escuela Superior de Conputo (ESCOM-IPN) y la UAM (Unidad Azcapotzalco). Este evento es una vez al anio, acude a la sede mas cercana a tu domicilio

Como Instalar MonoDevelop en Ubuntu Dapper for Geeks

Bueno, llevando un poco acabo la idea que yo mismo planteé, pues voy a poner un tutorial paso a paso de como instalar MonoDevelop con apt desde Ubuntu Dapper Drake.

Esto va a ser bastante corto.

1.- Abrir una consola

2.- Poner la siguiente linea:

# sudo apt-get install mono mono-gmcs mono-gac mono-utils monodevelop monodoc monodoc-http

Con eso se instala la interfaz gráfica (MonoDevelop 0.10), el compilador de C# 2.0 (gmcs), el entorno de ejecución, etc. Tambien se instala el compilador de C# 1.0 (mcs) pero ese no compila cuando usas clases que no estaban disponibles sino hasta la especificacion 2.0 (ej. System.Collections.Generic), por lo cual yo prefiero gmcs.

Los paquetes monodoc y modoc-http son los paquetes de ayuda.

3.- Instalar paquetes extra:

Para desarrollar en Java con mono:

#sudo apt-get install monodevelop-java

Para subir un servidor web para aplicaciones con ASP.NET 1.0 y 2.0 respectivamente

#sudo apt-get install mono-xsp

#sudo apt-get install mono-xsp2

Para usar un servidor apache en lugar del anterior, para ASP.NET 1.0 y 2.0 respectivamente:

#apt-get install mono-apache-server

#apt-get install mono-apache-server2

4. Aprendiendo a Compilar:

La interfaz gráfica de mono está bien para compilar aplicaciones GTK o Glade, pero no está diseñada para compilar aplicaciones de consola. No permite la entrada de datos desde el teclado. Suponiendo que tenemos un simple HolaMundo.cs, la forma en que tendriamos que compilarlo (desde la consola), sería:

#mcs HolaMundo.cs

ó

#gmcs HolaMundo.cs

Las lineas anteriores generarían un archivo exe (HolaMundo.exe) que contiene el CIL bytecode .

Para ejecutar ese archivo, desde consola:

#mono HolaMundo.exe

Ejecutarlo así, nos permite introducir datos desde el teclado.

Ahora, digamos que queremos enlazar ese archivo compilado a la compilacion de otro programa. Solo necesitamos poner (con mcs o gmcs):

#gmcs -lib:<ruta del Assembly, /home/usuario...> -r:HolaMundo.exe OtroPrograma.cs

Lo que genera OtroPrograma.exe .

Para ejecutar, solamente hay que hacer:

#mono OtroPrograma.exe

Bueno, eso es todo para este tutorial. Espero poner mas pronto. Mi objetivo es lograr que toda la información que yo tuve que buscar para que mi sistema funcionara como yo lo tengo, esté disponible aquí. Así, cuando yo pierda mi sistema, no tendré que volver a buscarlo todo y solo me dedicaré a seguir mis propios tutoriales, jaja.

GNU/Linux

Iba a usar este post para escribir mi crítica de "El Monje" (que acabo de terminar de leer), pero encontré algo que me ha parecido muy emotivo y que vale la pena publicar sobre cualquier opinión mia.

¡El software libre parece estar triunfando!

En la siguiente página hay links a noticias electrónicas sobre el impacto del software libre a nivel mundial:

http://members.lycos.co.uk/alldrivers/linuxscompanyspectrum/

Me parece una causa respetable la del software libre, y el Manifiesto GNU me convenció sin duda. Dicen que Linux es un sistema para desarrolladores, ingenieros, etc, pero yo pienso que puede ser un sistema para el usuario promedio.

Cualquier usuario que tenga el mínimo interés en aprender lo básico para manejar Windows, puede tener la capacidad de aprender lo básico para manejar cualquier distribución de Linux.

Ya que se termine esa cultura de pagar tu "certificación en MS office", eso NO SIRVE. Ya aprendan a usar la ayuda por si solos.

Solo voy a escribir esto por hoy, mañana la crítica de "El Monje".

Mas información sobre Linux:

http://www.getgnulinux.org/es/