Listas Enlazadas

package listas;

/**
*
* @author ventura
*/
/*Aqui tenemos las declaraciones de las variables dentro de la clase TOKEN que nos serviran
* para poder manejar los datos que vomos a mostrar en la lista enlazada.
*/
public class TOKEN implements Cloneable, Comparable {
private String nombre;
private String TipoDato;
private int Nolinea;
private boolean funcion;
private boolean arreglo;
private boolean estructura;
private int NoParametros;
private int NoColumna;
/*
* cargamos la funcion TOKEN con los parametros que le vamos a mandar a la funcion insertar
* el cual tenemos la siguiente funcion.
*/
public TOKEN(String nombre, String TipoDato, int NoLinea, boolean funcion, boolean arreglo, boolean estructura,int NoParametros, int NoColumna) {
setNombre(nombre);
setTipoDato(TipoDato);
setNolinea(NoLinea);
setFuncion(funcion);
setArreglo(arreglo);
setEstructura(estructura);
setNoParametros(NoParametros);
setNoColumna(NoColumna);
}



@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}

@Override
//esta funcion meteremos los datos que se estan agragando o mas bien es lo que veremos en consola cuanso la lista ya este llena
//con los get es como regresamos las variables ingresada en nuestra funcion.
public String toString() {
return " Linea leida: Nombre[ " + getNombre() + " ]" + " Tipo de dato [ " + getTipoDato() + " ]" + " numero Linea[ " + getNolinea() + " ]" + " Funcion" + " [" + isFuncion() + " ]" + "Arreglo [" + isArreglo() + "]" + " Estructura" + " [" + isEstructura() + " ]" + " Numero de parametros" + " [" + getNoParametros() + " ]" + " Numero de columna " + " [ " + getNoColumna() + " ]";
}

public int compareTo(Object o) {
TOKEN p = (TOKEN) o;

int valor = getNombre().compareTo(p.getNombre());

if (valor == 0) {
valor = getTipoDato().compareTo(p.getTipoDato());
}

return valor;
}

/**
* @aqui vemos los get y set respectivos de la clase
*/
public String getNombre() {
return nombre;
}

/**
* @param nombre the nombre to set
*/
public void setNombre(String nombre) {
this.nombre = nombre;
}

/**
* @return the TipoDato
*/
public String getTipoDato() {
return TipoDato;
}

/**
* @param TipoDato the TipoDato to set
*/
public void setTipoDato(String TipoDato) {
this.TipoDato = TipoDato;
}

/**
* @return the Nolinea
*/
public int getNolinea() {
return Nolinea;
}

/**
* @param Nolinea the Nolinea to set
*/
public void setNolinea(int Nolinea) {
this.Nolinea = Nolinea;
}

/**
* @return the funcion
*/
public boolean isFuncion() {
return funcion;
}

/**
* @param funcion the funcion to set
*/
public void setFuncion(boolean funcion) {
this.funcion = funcion;
}

/**
* @return the arreglo
*/
public boolean isArreglo() {
return arreglo;
}

/**
* @param arreglo the arreglo to set
*/
public void setArreglo(boolean arreglo) {
this.arreglo = arreglo;
}

/**
* @return the estructura
*/
public boolean isEstructura() {
return estructura;
}

/**
* @param estructura the estructura to set
*/
public void setEstructura(boolean estructura) {
this.estructura = estructura;
}

/**
* @return the NoParametros
*/
public int getNoParametros() {
return NoParametros;
}

/**
* @param NoParametros the NoParametros to set
*/
public void setNoParametros(int NoParametros) {
this.NoParametros = NoParametros;
}

/**
* @return the NoColumna
*/
public int getNoColumna() {
return NoColumna;
}

/**
* @param NoColumna the NoColumna to set
*/
public void setNoColumna(int NoColumna) {
this.NoColumna = NoColumna;
}

/**
* @return the Nolinea
*/

}
//aqui tenemos la clase TblSimbolos
package listas;


import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;


/**
*
* @author ventura
*/
public class TblSimbolo {
/*
*creamos un objeto de clase linkedList que ya viene incluida en las clases de java
* y se hace de la siguiente amanera
*/
List enlazada = new LinkedList();
//creamos la clase insertar en esta agregamos los token a la lista enlazada pasandole
//pasandole un parametro de tipo TOKEN
public void insertartk(TOKEN tkn) {
this.enlazada.add(tkn);
}

/*
* Continuamos con la funcion buscar que esta buscara un elemento en la lista enlazada
*
*/
public int buscar(String Nombre){
//se declara una variable de tipo booleano para usarlo como bandera y este nos ayudara a determinar el final
//de nuestra busqueda
boolean bandera=false;
//declaramos un objeto que sea un iterados para recorer la lista de elementos
Iterator id = enlazada.iterator();
int indice=-1;

//haremos un while donde donde deve cumplir con la condicion mientras que nose encuantre y bandera
//sea igual a false de esta forma segura buscando el elemento asta encontralo.
while (id.hasNext() && bandera==false){
//casteamos el id para que sea de tipo token y se lo asignamos al objeto creado que en este caso es a
TOKEN a = (TOKEN) id.next();
//mostramos el nombre y numero de linea una vez encontrado el elemento
System.out.println(a.getNombre() + " TOKEN LINEA " + a.getNolinea());
if(a.getNombre().equals(Nombre)){
System.out.println("Elemento Encontrado");
//si bamdera se convirte true el if termina y el elemento es encontrado
bandera =true;
//esta linea debuelve el indice que se usara para regresar el valor que se estaba buscando
indice = enlazada.indexOf(a);
System.out.println("El elemrto buscado es: " + a.getNombre());

}

}

return indice;
}
public void modificar(TOKEN buscado) {
/**
* Se hace la busqueda.
* declaramos una variable entera y le asignamos la funcion buscar esto hara que para poder modificar un elemento
* tenemos que encontrarlo primero por eso es que usamos la funcion buscar
*/
int index = this.buscar(buscado.getNombre());
//decimos que meintras el index sea igual a -1 el identificador no existira
if (index == -1) {
System.out.println("Ese identificador, NO EXISTE!!!");
return;
}
/**
* Se hacen las comprobaciones de atributos a cambiar, en el caso de los int
* si se recibe un dato diferente de -1 se realiza el cambio, mientras que
* si es boolean y se recibe algo distinto a un false tambien se hace el cambio.
*/
if (buscado.getNolinea() != 45) {
((TOKEN) enlazada.get(index)).setNolinea(buscado.getNolinea());
}
if (buscado.getNoColumna() != 34) {
((TOKEN) enlazada.get(index)).setNoColumna(buscado.getNoColumna());
}
if (buscado.isFuncion() != true) {
((TOKEN) enlazada.get(index)).setFuncion(buscado.isFuncion());
}
if (buscado.isArreglo() != false) {
((TOKEN) enlazada.get(index)).setArreglo(buscado.isArreglo());
}
if (buscado.isEstructura() != false) {
((TOKEN) enlazada.get(index)).setEstructura(buscado.isEstructura());
}
if (buscado.getNoParametros() != 3) {
((TOKEN) enlazada.get(index)).setNoParametros(buscado.getNoParametros());
}
if (buscado.getNoColumna() != 34) {
((TOKEN) enlazada.get(index)).setNoColumna(buscado.getNoColumna());

}

}
public void mostrar(){
//bien para mostrar en este caso los cambios que se realizaron en la funcion modificar hacemos la funcion mostrar
//en este caso creamos un objeto con el iterator y este recorre la lista enlazada para mostrr todos los
//elementos en la lista
Iterator itb = enlazada.iterator();
while(itb.hasNext()){
TOKEN b = (TOKEN) itb.next();
System.out.println(" Linea leida: Nombre[ " + b.getNombre() + " ]" + " Tipo de dato [ " + b.getTipoDato() + " ]" + " numero Linea[ " + b.getNolinea() + " ]" + " Funcion" + " [" + b.isFuncion() + " ]" + "Arreglo [" + b.isArreglo() + "]" + " Estructura" + " [" + b.isEstructura() + " ]" + " Numero de parametros" + " [" + b.getNoParametros() + " ]" + " Numero de columna " + " [ " + b.getNoColumna() + " ]");
}
}

public void insertar(TOKEN tkn) {
this.enlazada.add(tkn);
}

//aqui es donde tenemos la insersion de elementos en la lista enlazada la cual se llena en la \ejecuacion del programa
public TblSimbolo() {
try {
inicio();
} catch (CloneNotSupportedException ex) {
Logger.getLogger(TblSimbolo.class.getName()).log(Level.SEVERE, null, ex);
}
}

public static void main(String[] args) {
new TblSimbolo();

}

public void inicio() throws CloneNotSupportedException {
System.out.println("Inicio de la aplicación.\n");
//aqui podemos observar que la insercion se hace con un for y de este modo insertamos los elementos en la
//lista.

for (int i = 0; i < 10; i++) {
//creamos un objeto de tipo TOKEN para pasarle esos valores a la funcion que creamos en la clase TOKEN
TOKEN tk = new TOKEN("Variable " + i," Int ",45,true, false, false,2,34);
//Añadimos el objeto
this.insertar(tk);
}

}

}

//aqui muestro la clase main donde mandamos llamar los metodos

package listas;

import java.util.Scanner;
import javax.swing.JOptionPane;

/**
*
* @author ventura
*/
public class main {
@SuppressWarnings("empty-statement")
public static void main(String[] args) throws CloneNotSupportedException {
//esta variable nos servira para volver a elegis las opciones que aparecen en nustro menu del programa
//en su ejecuacion
String elige;

//con el uso de do while vamos a mostrar nuestras operaciones de forma organizada y tantas veces como queramos
do {
//instanciamos la clase TblSimbolo para poder usar las funciones que tenemos en ella
TblSimbolo tabla = new TblSimbolo();
//la clase scanner no servira para introducir nuestra opcion directamente en la consola
Scanner lee = new Scanner(System.in);
//acontinuacion se muestra el menu con las posibles opciones que se necesiten hacer.
System.out.println("LOS DATOS YA ESTAN INGRESADOS");
System.out.println("ELIGE TU OPCION");

System.out.println("1.- BUSCAR ELEMENTO");
System.out.println("2.- MODIFICAR ELEMENTO");


//declaramos la variable lee para poder acceder a los casos en el switch
int opcion = lee.nextInt();
switch(opcion) {
case 1:
System.out.println("HAS ELEGIDO BUSCAR ELEMENTO \n");

String dato;
//dato obtendra el valor ingresado en el JOption pane
dato = JOptionPane.showInputDialog("Ingresa el valor a buscar", lee.nextLine());
//y selo pasamos como paremetra a la funcion buscar
tabla.buscar(dato);

break;
case 2:
System.out.println("HAS ELEGIDO MODIFICAR ELEMENTO");
//nuevamente para modificar le asignamos el valor obtenido a la variablle dato la cual
//leemos la opcion con la siguiente linea
dato = JOptionPane.showInputDialog("Ingresa el valor a buscar", lee.nextLine());
//creamos em objeto tk y agragamos el cambio conforme al dato que se busco
//si lo encuentra hacer los combios que se le indican con la funcion que se encuantra en la siguiente linea.
TOKEN tk = new TOKEN(dato," Int ",45,false, true, true,2,34);
//ise manda llamar con el objeto tabla de la clase TblSimbolo
tabla.modificar(tk);
tabla.mostrar();
break;
default:
//bueno en caso de no elegir ninguna opcion te mostreria este mensaje
System.out.println("No se eligio ninguna opcion");
break;
}
System.out.println("\n\n\n TERMINA CICLO DE WHILE");
System.out.println("Para mostrar menu elige 1");
elige = JOptionPane.showInputDialog("Quires ver menu ingresa yes");
//la siguiente linea determina que se no introduces como respuesta yes no podras continuar con el programa

}while(elige.equals("yes"));


}

}

Algoritmo

1.- inicio
2.- declara matriz
{0,1,2,3,4},
{1,2,2,6,6},
{2,3,3,6,6},
{3,4,4,6,6},
{4,5,6,6,6},
{5,5,5,6,5},
{6,6,6,6,6}};
3.- declara cadena
char cadena[50];
4.- declara la variable C
int c=0
5.- declara variable estado
estado=1
6.- Muestra mensaje "Introduce cadena"
7.- introduce cadena
cin>>cadena;
8.- para n de la cadena
si n<=0
9.- si cadena en la posicion n='a'
c=1
10.- si cadena en la posion n='b'
c=2
11.- si cadena en la posicion n=!(a|b)
c=3
12.- fin si
13.- fin si
14.- aumenta n++
15.- si estado ==5
16.- Imprime "cadena aceptda"
17.- si no
18.- "Imprime cadena rechazada"
19.- fin si
20.- fin

JLEX

JLex es un generador de analizadores sintácticos para el sistema operativo UNIX, dirigida al lenguaje de programación C. Lex toma una especificación de formato especial-archivo que contiene los detalles de un análisis léxico. Esta herramienta crea un C archivo de fuente para la tabla asociada impulsada léxico.
Especificaciones jlex.
Un archivo de entrada JLex está organizado en tres secciones, separadas por dos directivas por ciento (``%%''). Una especificación adecuada JLex tiene el siguiente formato.
código de usuario
%%
Directivas JLex
%%
reglas de expresiones regulares
Las directivas ``%%'' distinguir las secciones del archivo de entrada y debe ser colocado al principio de su línea. El resto de la línea que contiene las directivas ``%%'' se puede descartar y no debe ser utilizado para albergar a más declaraciones o código.
Código de usuario
Código de usuario precede a la primera doble Directiva por ciento (``%%'). Este código es copiado literalmente en la fuente de analizadores sintácticos de archivo que los productos JLex, en la parte superior del archivo.
Jlex directivas
La sección de la Directiva JLex empieza después de la primera ``%%'' y continúa hasta el delimitador ``%%'' segundo. JLex Cada directiva debe incluirse en una sola línea y comenzar esa línea.

Objetivos y filosofia del lenguaje

Objetivos:
Sencillo y familiar: sencillo para que no requiera grandes esfuerzos de entrenamiento
Para los programadores familiar por que será comprendido por sus desarrolladores de forma muy fácil.

Filosofia:
Este lenguaje de programación esta orientado en una forma directa consistiendo en que siempre se
tenga respuesta a su algoritmo y le sea fácil programar.

Gramatica de lenguaje

Gramatica del lenguaje invetado el cua nos ayudara a poder programar abiertamente el sistema que estemos diseñando un lenguaje practico y comodo.

Programa -> Lista_sentencias.
Lista_sentencias -> Lista_sentencias Sentencias
Lista_sentencias -> sentencias
Sentencias -> FOR
Sentencias -> IF
FOR -> for (condicion) sentencia
FOR -> for (condicion) { Lista_sentencias }
IF -> if (condicion) sentencias
IF -> if (condicion) { Lista_sentencias }
IF_ELSE -> if_else sentencias
IF_ELSE -> if_else { Lista_sentencias }
Condicion -> condicion logica condicion_AND condicion_OR
Condicion_AND -> condicion logica && condicion logica
Condicion logica -> E>E E=E E<= E E==E E!=E
E -> E+T E-T T
T -> T*F T/F F
F -> i c

Chequenlo y pues acepto sugerencias.