El adaptador Conexión de area local está deshabilitado – Windows 7
Cuando no se puedan conectar a internet por medio del cable de red, en windows 7, y le den analizar errores y les salga el error “El adaptador Conexión de area local está deshabilitado”:
Lo que hay que hacer es irse a panel de control, redes e internet, centro de redes y recursos compartidos.. leer el resto de la entrada…
el adaptador de red inalambrica no esta conectado – windows vista
este mensaje aparece cuando no se puede conectar a la red wireless en windows vista, o tambien cuando aparece el error: “ESTA red no requiere autenticacion inalambrica con 802.1x para
conectarse” la solucion es sencilla, simplemente tienen que ir al panel de redes
Arbol B en java y netbeans
El siguiente es une programa en Netbeans que guarda datos de clientes usando la estructura de datos Arbol b, tiene la opcion de guardar, modificar, insertar nuevo, eliminar, buscar, además grafica el arbol b usando Graphviz, esta hecho en java,
Arbol B
descarga: http://www.divshare.com/download/118508
Habilitar Red Wireless en Ubuntu
Instalar red wirelles en Ubuntu en una laptop Dell es un gran vergueo, para empezar, hay que primero que todo instalar linux con el alambre de internet wired conectado, el que viene del modem, asi de una vez a la hora de instalar el sistema instala la red cableada y asi podemos empezar a usar internet cableado, que nos va a servir para bajar el driver de wirelles.
JLex y Cup EN NETBEANS Y WINDOWS Vista
Posteare en esta ocasion la manera de empezar a trabajar con las herramientas de Analisis lexico jlex y cup , la herramienta jlex para el scanner y cup para el parser, en Netbeans y Windows vista por medio de un simple analizador que lo que va a realizar es leer un archivo de entrada y reconocer las palabras que encuentre por medio de unas palabras reservadas que le vamos a indicar. Todo esto se realizo en el Sistema Operativo Windows vista.
Primero que todo, si quieren saltarse toda la explicacion que daré del programa y quieren bajar el proyecto en netbeans completo, descarguenlo de aca: http://www.divshare.com/download/11850822-563
para ver los pasos a seguir para empezar a usar desde cero jlex y cup en su pc realizen lo siguiente:
CONFIGURACION DE LAS VARIABLES DE ENTORNO
No olviden que primero tienen que configurar sus variables de entorno, si no saben como hacerlo , simplemente abrimos un terminal cmd , nos situamos dentro de la carpeta bin , la que se encuentre en la ruta c:\Archivos de programa\java\jdk1.5.1\bin escribiendo cd c:\Archivos\java\jdk1.5.1\bin, como se ve en el ejemplo siguiente:
ya estando alli situados, escribimos lo siguiente
set CLASSPATH=c:\Archivos\java\jdk1.5.1\bin;%CLASSPATH%
set PATH=c:\Archivos\java\jdk1.5.1\bin;%PATH%
lo mismo para el path.
INSTALACION DE JLEX
Lo siguiente que debemos realizar es bajar la clase Main.java la cual nos sirve para instalar jlex, la pueden conseguir del siguiente enlace : JLEX .
En esa ruta encontramos el archivo Main.java, podemos copiar todo ese codigo, pegarlo en un archivo txt y guardarlo como Main.java. ahora ya tenemos nuestra clase Main.java con el codigo fuente de JLex, que es el analisis lexico, pero ahora falta compilar esa clase, para eso nos vamos a la carpeta /bin dentro de la ruta de java, que por lo regular es C:/Archivos de programa/java/jdk1.5.11_0/bin
.
Ya estando dentro de /bin creamos una nueva carpeta llamada JLex, dentro de esta carpeta copiamos la clase Main.java que conseguimos anteriormenter, con lo que nos quedaría la ruta /bin/JLex/Main.java. Ahora compilemos la clase JLex, abrimos un terminal cmd , en inicio/ejecutar/, escribimos cmd, les aparecera una terminal, teclean cd C:/Archivos de programa/java/jdk…../bin , esto nos colocará en el directorio bin, luego compilan Jlex, para esto teclean javac JLex/Main.java,
esto les generará los .class dentro de la carpeta Jlex, que necesita JLex para trabajar correctamente.
INSTALACION DE CUP
Ahora colocar en esta misma carpeta bin la carpeta java_cup que pueden descargar de aca java_cup .
si no sirve ese link vayan a la pagina de cup, que es http://www2.cs.tum.edu/projects/cup/ y descarguen cup.zip de alli
luego de descargarla, la descomprimen, y en las tres carpetas que aparecen eligen la que se llama java_cup.
Como ven colocamos la carpeta en la ruta del bin:
la razon por la cual se colocan estas carpetas JLex y java_cup en esta ruta bin es porque mas adelante a la hora de querer procesar sus archivos de entrada .lex y .cup necesitaemos usar los comandos java JLex.Main miarchivo.lex y java java_cup.Main miarchivo. cup, entonces para que esos comandos funcionen tiene java que ver que las carpetas JLex y java_cup esten registradas en su ruta, la bin del jdk, localizada en c:\Archivos de programas\java\jdk1.5.1\bin,. Si java no encuentra esas carpetas en esa ruta les dara error, pero recuerden que solo la carpeta JLex tienen que compilar a mano ya que la java_cup de cup ya viene compilada con sus .class dentro. pero eso lo pueden ver mas adelante a la hora que lo realizemos.
Lo siguiente es crear un nuevo proyecto en Netbeans, en este ejemplo le llamaremos proyecto1.
luego se van a la carpeta de su proyecto en Netbeans, proyecto1/src/proyecto1
Alli copian la carpeta de JLex que teniamos en la ruta de jdk, la carpeta JLEX que acabamos de crear, tambien copian la carpeta java_cup que habiamos bajado anteriormente, Si mas adelante les da problemas o si no consiguieron la carpeta java_cup vayan al sitio oficial de cup y descarguenla de alli
El objetivo es tener JLex y main_cup en su carpeta de proyecto proyecto1/src/proyecto1 para cuando compilemos mas adelante encuentre la ruta. si no funcionan los que descargaron aca prueben con otros, que a veces difiere de la versión de java que tengan.
Asumiendo que ya lograron todo eso, pues construimos nuestros archivos lex y cup de ejemplo, en este caso le llamaremos _scanner.txt al de lex y _parser.txt al que contendra el ejemplo cup. La estructura de mi archivo _scanner.txt la muestro a continuación:
Si se fijan esto contiene las directivas JLex, para reconocer los tokens, punto y coma, dos puntos,coma, punto coma, parentesis, dos puntos, diagonal , asi como la frase alfanumerica que acepta letras o números o el simbolo _, que es la expresion regular (“_”|{ALPHA_NUMERIC})(“_”|{ALPHA_NUMERIC})*, lo que va a hacer esta aplicación es que en base a mi archivo de entrada va a desplegar un mensaje dependiendo de que token (caracter) encuentre.
Si no logran ver bien el codigo anterior aca lo pongo
package proyecto1;
import java_cup.runtime.*;
import javax.swing.*;
import java.util.*;
import proyecto1.*;
%%
%class Yylex
%{String literal;
String temp_include;
%}
%{
int columna=1;
%}
%public
%cup
%line
%full
%unicode
%ignorecase
%char
%{
public String sourceFilename;
StringBuffer string = new StringBuffer();
int ultimoEstado = 0;
public void init(){};
%}
%eofval{
{return new Symbol(sym.EOF, null); }
%eofval}
ALPHA=[A-Za-z]
DIGITO=[0-9]
ALPHA_NUMERIC={ALPHA}|{DIGITO}
NEW_LINE=(\n|\r)
WHITE_SPACE=([\ |\t|\f])
LineTerminator = \r|\n|\r\n
InputCharacter = [^\r\n]
st = [^\\\n\"]+ | [\\][\\] | “\\\”" | “\\\’” |”\\t”| “\\n” | “\\r” |”\\b” |”\n”
FRASE=(“_”|{ALPHA_NUMERIC})(“_”|{ALPHA_NUMERIC})*
%%
[\n] { yychar=0;}
[ \t\r\n\f] { /* ignore white space. */ }
\’ { /* ignore apostrofos. */ }
<YYINITIAL> {WHITE_SPACE} {/*no hace nada, aumenta una columna*/yychar++; }
<YYINITIAL> {NEW_LINE} {yychar=0; yyline=0}
<YYINITIAL>”(” { return new Symbol(sym.OPEN, yyline, yychar, yytext());}
<YYINITIAL>”)” { return new Symbol(sym.CLOSE, yyline, yychar, yytext());}
<YYINITIAL>”;” { return new Symbol(sym.PUNTOCOMA, yyline, yychar, yytext());}
<YYINITIAL>”:” { return new Symbol(sym.DOSPUNTOS, yyline, yychar, yytext());}
<YYINITIAL>”,” { return new Symbol(sym.COMA, yyline, yychar, yytext());}
<YYINITIAL>”/” { return new Symbol(sym.DIAGONAL, yyline, yychar, yytext());}
<YYINITIAL>”=” { return new Symbol(sym.EQUALS, yyline, yychar, yytext());}
<YYINITIAL>{FRASE} { return new Symbol(sym.FRASE, yyline, yychar, yytext());}
. {
System.out.println(“error lexico en la fila “+yyline +” y en la columna ” + yychar);
interfaz.rotular(“error lexico :”+ yytext()+” en la fila “+yyline +” y en la columna ” + yychar);
}
Ahora vamos a ver la estructura que voy a usar en mi gramatica, osea en mi archivo _parser.txt , la detallo a continuación:
Este archivo lo que contiene es mi gramatica sencilla, solo que acepte infinitas sentencias separadas de espacios en blanco.
Si no logran ver aca coloco el codigo anterior
package proyecto1;
import java.io.*;
import java.lang.*;
import java_cup.runtime.*;
import java_cup.runtime.Symbol;
import java.util.ArrayList;
import java.util.*;
import proyecto1.*;
action code{:
void print(String msj)
{System.out.println(msj);}
:}
parser code {:
public void syntax_error(Symbol cur_token){
System.out.println(“va a ingresar el error sintactico “+ cur_token.value);
interfaz.rotular(“va a ingresar el error sintactico “+ cur_token.value);
}
public void unrecovered_syntax_error(Symbol s) throws java.lang.Exception{
interfaz.rotular(“errror YA no se recupera”);
System.out.println(“error YA no se recupera”);
}
public void semantic(Symbol cur_token,String n)
{
System.out.println(“error semantico “);
}
public void semantic(String msg, Object obj) {
}
:};
//////////////////////////////////////////////////////////////////
///////simbolos terminales generales//////////////////
////////////
//////////////////////////////////////////////////////////////////
terminal COMA,PUNTOCOMA,DIAGONAL,DOSPUNTOS, OPEN,CLOSE,EQUALS;
terminal FRASE;
////////////////////////////////////////////////////////////////////
////////////////////////SIMBOLOS NO TERMINALES /////////////////////
/////////////////////////////////////////////////////////////////////
non terminal START, INICIO;
non terminal String SIMBOLO;
//////////////////////////inicio de la gramatica ///////////////////////////////////
start with START;
START ::= START INICIO
| INICIO
;
INICIO::= FRASE:d {: interfaz.rotular(“Se reconocio una frase alfanumerica : “+ d.toString());:}
| SIMBOLO :d {:interfaz.rotular(“Se reconocio el token “+d.toString());:}
;
SIMBOLO ::= COMA:d {: RESULT =d.toString();:}
| PUNTOCOMA :d {: RESULT =d.toString();:}
| DIAGONAL:d {: RESULT =d.toString();:}
| DOSPUNTOS:d {: RESULT =d.toString();:}
| EQUALS:d {: RESULT =d.toString();:}
| OPEN:d {: RESULT =d.toString();:}
| CLOSE:d {: RESULT =d.toString();:}
;
/****************************Fin de la gramatica************************************************
*/
Este archivo contiene la gramatica del proyecto, tal como se indica.
Entonces estos dos archivos, el _scanner.txt y _parser.txt los coloco en el directorio proyecto1/src/proyecto1 de mi proyecto en Netbeans:
si se fijan alli aparece la clase Main.java ,esas se creo al hacer el proyecto de Netbeans, y también aparecen mi carpeta JLex que copie aca, la que contiene todos los .class que habiamos compilado anteriormente y tambien aparece la carpeta java_cup que contiene todos los .class que habiamos bajado anteriormente , y aparecen también nuestros archivos _scanner.txt y _parser.txt.
Ahora lo siguiente es compilar a mano estos archivos para generar las clases Yylex.java sym.java y parser.java que va a usar Netbeans mas adelante, para hacer esto nos vamos a nuestra terminal, nos colocamos en este directorio que mostre, osea a proyecto1/src/proyecto1, para colocarnos alli colocamos en consola el comando cd C:/Users/documents/NetbeansProyect/proyecto1/src/proyecto1
Esto en mi caso, en el caso de ustedes coloque luego de cd la ruta de sus archivos de prueba _scanner.txt y _parser.txt, ya estando colocados dentro de esa ruta, compilamos el archivo _scanner.txt usando los siguientes comandos: java JLex.Main _scanner.txt
aca ilustro esto:
Esto procesa los comandos anteriores y crea la clase _scanner.txt.java,
este archivo lo renombro a Yylex.java para que pueda funcionar el proyecto
quedaria asi:
Ahora compilo mi archivo _parser.txt, el que contiene mi gramática, para eso ingreso el comando java java_cup.Main _parser.txt
Esto procesa mi archivo _parser.txt reconociendo los terminales y no terminales que declaremos, tambien generará las clases parser.java y sym.java , necesarias para que Netbeans pueda trabajar, ya que Netbeans las llama en sus metodos.
Algo importante es que no tiene que generar ningun tipo de error los procesos anteriores, si da un error en consola es porque tienen algo malo en sus archivos lex y cup. revisen en la parte de sus files que no haya ninguna clase marcada en rojo, todo tiene que estar limpio :
como veran ya tenemos todo generado, ahora lo siguiente es crear una clase de tipo Frame, que vamos a llamar interfaz.java
Esta fila va a contener la interfaz grafica de la aplicación, Ahora nos vamos a la clase Main.java, osea la que contiene el metodo public static void Main( String args), dentro de esta clase creamos un metodo llamado Main(), osea uno constructor este no es el principal el (string args) que viene por default sino es uno consructor que hacemos a mano, alli colocamos lo siguiente
Este metodo lo que hace es escanear y parsear un archivo llamado entrada.txt , el cual mas adelante crearé desde mi interfaz grafica en Netbeans. Noten que las palabras Parser y Yylex que ponemos arriba no son mas que las referencias a las clases Yylex y Parser que creamos anteriormente.
El codigo de la anterior imagen (clase main) es:
package proyecto1;
import java.io.*;
import javax.swing.*;
/**
*
* @author HOME
*/
public class Main {
Main() {
String path;
parser ThisParser;
Yylex ThisScanner;
path=”entrada.txt”;
try
{ ThisScanner= new Yylex (new FileReader (path));
ThisParser=new parser (ThisScanner);
ThisParser.parse ();
interfaz.rotular( “end of scanner”);
}catch(Exception e)
{interfaz.rotular(“se arruino en el proceso “+e.toString());}
}
public static void main(String[] args) {
new interfaz().setVisible(true);
}
}
Ahora lo siguiente es irse a la javax swing form class llamada interfaz que habiamos creado, arrastramos del palette un jTextArea1, para escribir el texto , y un boton,
Ahora en esa clase ponemos hasta arriba import java.io.*;import javax.swing.*;
Esta clase interfaz.java lo que va a hacer es que cuando presionamos el boton scan, inmediatamente va a crear un archivo de texto llamado entrada.txt en la carpeta del proyecto1, entonces ese archivo de texto creado va a contener todo el texto que esta en mi jTextArea de la izquierda, para asi cuando ejecuto el boton, al mismo tiempo que se guarda , ese mismo archivo se usa para cuando llamemos al metodo Main(), y ese mismo sea el que escanee y parsee. el codigo que puse dentro del boton scan es el siguiente:
Donde el metodo guardar() es:
public void guardar() {
String uno=new String();
uno=jTextArea1.getText();
try {
File file1 = new File(“entrada.txt”);
BufferedWriter output = new BufferedWriter(new FileWriter(file1));
output.write(uno);
output.close();
}
catch(Exception e) {
JOptionPane.showMessageDialog(null, “No se pudo guardar archivo de entrada debido a “+ e.toString());
}
}
y el metodo new Main() es el que detalle mas arriba .
Ahora arrastramos otro JtextArea2, que nos va a servir para desplegar los resultados.
pongan los jtextareas como publicos y estáticos en sus propiedades, sino no va a dejar llamarlos
Ahora finalmente colocamos en esta mi clase interfaz.java los siguientes dos metodos para que funcione bien:
El codigo de los anteriores metodos es:
public static void rotular(String name){
jTextArea2.setText( jTextArea2.getText()+name+”\n”);
}
public static void rotular2(String name){
jTextArea1.setText( jTextArea1.getText()+name+”\n”);
}
Ahora solo nos queda debuggear el proyecto y probarlo, nos vamos al menu ayuda, le damos cargar archivo, lo que nos va a mostrar unos comandos de prueba en el tablero, y luego presionamos scan.
nos damos cuenta nos muestra los tokens encontrados, su valor y también los posibles errores lexicos que encuentra con su linea y columna
Nota: el menu ayuda solo esta disponible si bajaron el proyecto completo. si lo hicieron a mano tendran que ingresar los tokens a mano,
Espero que les haya servido de algo esta guia, si quieren ingresar nuevos valores que reconozca jlex en la gramatica , van a tener que seguir todos estos pasos para que funcion en su pc Jlex y cup
La verdad es que este tipo de cosas salen mejor en Linux.
y ya teniendo esto ya pueden realizar el tipico ejemplo de la suma y resta (calculadora) , solo es cuestión de cambiarle la gramatica del archivo cup y modificar el lex
