Códigos intermedios

En este primer programa, tenemos un analizador semántico programado en NetBeans.

En este caso, tenemos los analizadores léxicos y sintácticos, por lo cual, el programa es

multifuncional.

Ahora, analizaremos cada una de sus clases.

Primordialmente vemos que cuenta con demasiados iconos, los cuales,

son funcionales para la interfaz gráfica del programa, en general, cuenta

con un sistema de loggeo, para ingresar a la interfaz del compilador.

Cuenta también con varios ejemplos de clases, para nosotros

hacer pruebas del compilador, al igual, que vemos las clases

de información, instructivo, la ventana, fondo, y las

instrucciones de uso del programa.

Analizaremos cada uno de los apartados para ver como

implementamos estas clases a la clase principal.

Por lo tanto, empezaremos con la información de la clase.

Tiene un apartado gráfico en donde tenemos la información

del autor:
El siguiente apartado es de instructivos:

Tenemos las declaraciones de variables NUM, DNUM, WORD.

En el siguiente se implementan las librerías que se van a utilizar en el código:
package lexicosintactico;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StreamTokenizer;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.StringTokenizer;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.table.DefaultTableModel;

Teniendo las siguientes librerías, el analizador debe funcionar correctamente, Luego de

ello, tenemos la primera clase de Ventana, la cual, nos servirá para implementar nuestra

interfaz gráfica:

public class Ventana extends javax.swing.JFrame {

FileNameExtensionFilter filtro= new FileNameExtensionFilter("Archivos Word y

txt","docx","txt");

File f;

JFileChooser j= new JFileChooser();

String data1 [][]={};

String cabecera1[]={"No."," Token "," Tipo"};

 String path;

int cont=0;

int errores;

String mensajini="";

String tipo="";

public Ventana() {

initComponents();

Aquí implementamos la barra de opciones de la interfaz

También implementan una hoja en blanco para el apartado de escribir un código fuente que

será el que se debe analizar:

Terminada la interfaz gráfica, empezaremos poniendo los métodos del código fuente:
Por último, tenemos las diferentes variables compuestas:
while((aux = br.readLine())!=null)

lectura = lectura+aux+"\n";//Voy acumulando todo en un string

}catch(IOException e){}

txtATexto1.setText(lectura);//Mando lo que resulto de la lectura

int contador=0;
StringTokenizer st = new StringTokenizer(txtATexto1.getText(),"\n",true);
String Text = "",token;
contador = 1;

while (st.hasMoreTokens()){
token= st.nextToken();
if("\n".equals(token)) contador++;
}

for(int i = 1; i <= contador; i++){

Text += i+"\n";
}
Lineas.setText(Text);

//contarCaracteres(lectura);//Mando llamar el metodo de contar caracteres

//mayusculasyminusculas(lectura);
}catch(NullPointerException e){
 javax.swing.JOptionPane.showMessageDialog(j, "Has seleccionado cerrar
programa, saliendo...");

System.exit(0);

}
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

HashMap <String,Integer> r = new HashMap<>();
HashMap <String,Integer> op = new HashMap<>();
HashMap <String,Integer> id = new HashMap<>();
HashMap <String,Integer> deli = new HashMap<>();
HashMap <String,Integer> num = new HashMap<>();
LinkedList <String> texto = new LinkedList<>();

r.put("BEGIN", 0);
r.put("END", 0);
r.put("WORD", 0);
r.put("ALFA", 0);
r.put("NUM", 0);
r.put("DNUM", 0);
r.put("BOOL", 0);
r.put("LNUM", 0);
r.put("TAKE", 0);
r.put("SEND", 0);
r.put("WHEN", 0);
r.put("IT", 0);
r.put("IS", 0);
r.put("START", 0);
r.put("STEP", 0);
r.put("TO", 0);
r.put("STOP", 0);
r.put("SWHEN", 0);
r.put("COMPLETE", 0);

op.put("/", 0);
op.put("*", 0);
op.put("+", 0);
op.put("-", 0);
op.put("=", 0);
op.put("^", 0);
op.put("<", 0);
op.put(">", 0);
op.put("||", 0);
op.put("&&", 0);
 deli.put("#", 0);
deli.put(";", 0);
deli.put("{", 0);
deli.put("}", 0);
deli.put(")", 0);
deli.put(",", 0);
deli.put("(",0);

DefaultTableModel model = new DefaultTableModel();

model.setColumnIdentifiers(new Object[]{"Token","Cantidad","Tipo"});

StringTokenizer st = new StringTokenizer(txtATexto1.getText(),"{}();,\"=+-*/><||

&&# \n\t",true);
String token, text = "";
while (st.hasMoreTokens()){
token = st.nextToken();
if(!" ".equals(token) && !"\n".equals(token) && !"\t".equals(token)){
if (r.containsKey(token)) {
r.put(token, r.get(token)+1);
}else {
if (op.containsKey(token)) {
op.put(token, op.get(token)+1);
}else {
if (deli.containsKey(token)){
deli.put(token, deli.get(token)+1);
if("#".equals(token)){
token = st.nextToken();
while (st.hasMoreTokens() && !"#".equals(token)){
text += token;
token = st.nextToken();
}
texto.add(text);
deli.put(token, deli.get(token)+1);
text = "";
}
}else {
if (id.containsKey(token)) {
id.put(token, id.get(token)+1);
}else {
if(token.matches("([0-9]*)|([0-9]*.[0-9]+)")) {
if (num.containsKey(token)) {
num.put(token, num.get(token)+1);
}else num.put(token, 1);
}
 else id.put(token, 1);
}
}
}
}
}
}

Iterator<String> itr = r.keySet().iterator();

while(itr.hasNext()){
token = itr.next();
if(r.get(token) > 0)model.addRow(new Object[]{token, r.get(token),"Palabra
Reservada"});
}
itr = op.keySet().iterator();
while(itr.hasNext()){
token = itr.next();
if(op.get(token) > 0) model.addRow(new Object[]{token,
op.get(token),"Operador"});
}
itr = deli.keySet().iterator();
while(itr.hasNext()){
token = itr.next();
if(deli.get(token) > 0) model.addRow(new Object[]{token,
deli.get(token),"Delimitador"});
}
itr = id.keySet().iterator();
while(itr.hasNext()){
token = itr.next();
if(id.get(token) > 0) model.addRow(new Object[]{token,
id.get(token),"Identificador"});
}
itr = num.keySet().iterator();
while(itr.hasNext()){
token = itr.next();
if(num.get(token) > 0) {
if(token.matches("[0-9]+"))model.addRow(new Object[]{token,
num.get(token),"Número"});
if(token.matches("[0-9]+.[0-9]+"))model.addRow(new Object[]{token,
num.get(token),"Número Decimal"});
}
}
itr = texto.iterator();
while(itr.hasNext()){
model.addRow(new Object[]{itr.next(), "1","Texto"});

}
 tabla.setModel(model);
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

errores=0;
LinkedList <String> ENT = new LinkedList<>();
LinkedList <String> DEC = new LinkedList<>();
LinkedList <String> TEXT = new LinkedList<>();
LinkedList <String> TAKE = new LinkedList<>();

String
simbolo = "([=<>])",
id = "([(a-z)(A-Z)](\\w)*)",
num = "((\\d)+)",
dec = "((\\d)+(\\.)(\\d)+)",
text = "((((#)[.\\W\\w\\s]*(#))|("+id+"))((\\s)*(\\+)((\\s)*((#)[.\\W\\w\\s]*(#))|
("+id+")))*)",
send = "((\\s)*SEND(\\s)*(\\()(\\s)*((((#)[.\\W\\w\\s]*(#))|("+id+"))((\\s)*(\\+)((\\
s)*((#)[.\\W\\w\\s]*(#))|("+id+")))*)(\\s)*(\\))(\\s)*(;))",
//take = "((\\s)*TAKE(\\b)(\\s)*"+id+"((\\s)*(,(\\s)*"+id+"))*(\\s)*(;))",
take = "((\\s)*TAKE(\\s)*(\\()(\\s)*((((#)[.\\W\\w\\s]*(#))|("+id+"))((\\s)*(\\+)((\\
s)*((#)[.\\W\\w\\s]*(#))|("+id+")))*)(\\s)*(\\))(\\s)*(;))",
operaciones = "(("+id+"|"+num+"|"+dec+")(\\s)*([+-/*](\\
s)*("+id+"|"+num+"|"+dec+"))+)",
defVal = "((\\s)*"+id+"(\\s)*=(\\
s)*("+id+"|"+text+"|"+operaciones+"|"+num+"|"+dec+")(\\s)*(;))",
defValVar = "((\\s)*"+id+"(\\s)*=(\\
s)*("+id+"|"+text+"|"+operaciones+"|"+num+"|"+dec+")(\\s)*)",
condicion = id+"(\\s)*"+simbolo+"(\\s)*("+id+"|"+num+"|"+dec+")((\\s)*([(&&)
(||)](\\s)*"+id+"(\\s)*"+simbolo+"(\\s)*("+id+"|"+num+"|"+dec+")))*",
var = "((\\s)*((NUM)|(DNUM)|(WORD))(\\b)(\\s)*("+id+"|"+defValVar+")((\\
s)*(,(\\s)*("+id+"|"+defValVar+")))*(\\s)*(;))",
main = "((\\s)*"+id+"(\\b)(\\s)*BEGIN(\\s)*(\\{)[.\\W\\w\\s]*(END(\\s)*(\\})(\\
s)*)$)",
main2 = "((\\s)*"+id+"(\\b)(\\s)*BEGIN(\\s)*(\\{))",
main3 = "((\\s)*END(\\s)*(\\})(\\s)*)",

start2 = "((\\s)*START(\\b)(\\s)*("+id+"|"+num+")(\\b)(\\
s)*(=)*("+id+"|"+num+")(\\b)(\\s)*(STEP)(\\b)(\\s)*"+num+"(\\s)*[+-]?(\\s)*(\\b)(TO)(\\b)
(\\s)*("+id+"|"+num+")(\\s)*(\\{))",
start3 = "((\\s)*STOP(\\s)*(\\}))",
when2 = "((\\s)*WHEN(\\s)*(\\()(\\s)*"+condicion+"(\\s)*(\\))(\\s)*(\\{))",
when3 = "((\\s)*SWHEN(\\s)*(\\}))",
it2 = "((\\s)*IT(\\s)*(\\()(\\s)*"+condicion+"(\\s)*(\\))(\\s)*(\\{))",
it3 = "((\\s)*COMPLETE(\\s)*(\\}))",
entero = "[0-9]*",
decimal = "[0-9]*.[0-9]+";
 LinkedList <Integer> error = new LinkedList<>();
StringTokenizer st = new StringTokenizer(txtATexto1.getText(),";{}",true);
String token = "", txt = "", e;
int i = 1, mainE = 0, start = 0, when = 0, it = 0, eB = 0;
Error.setText("");

if(txtATexto1.getText().matches(main)) {

while (st.hasMoreTokens()){
token = st.nextToken();
if(st.hasMoreTokens())token = token+st.nextToken();
if(token.matches("[.\\W\\w\\s]*(\\})") && st.countTokens() == 1){
String auxTok = st.nextToken();
token = token+(auxTok.substring(0,auxTok.indexOf("\n")));
}
StringTokenizer lin = new StringTokenizer(token,"\n",true);
while (lin.hasMoreTokens()){
e = lin.nextToken();
if("\n".equals(e)) i++;
}

if(token.matches(start2)) start++;
if(token.matches(start3)) start--;
if(token.matches(when2)) when++;
if(token.matches(when3)) when--;
if(token.matches(it2)) it++;
if(token.matches(it3)) it--;
if((st.hasMoreTokens() == false && (start > 0 || when > 0 || it > 0)) || (start
< 0 || when < 0 || it < 0)) eB = 1;

if((token.matches(send) || token.matches(take) || token.matches(var) ||

token.matches(defVal) || token.matches(main2) || token.matches(main3) ||
token.matches("(\\s)*(\\$)") || token.matches(start2) || token.matches(start3) ||
token.matches(when2) || token.matches(when3) || token.matches(it2) || token.matches(it3))
&& eB == 0){
if(token.matches(take)){

}
if(token.matches(var)){
StringTokenizer stTipo = new StringTokenizer(token," ,;");
String tipo = stTipo.nextToken();

if(tipo.contains("NUM")){

while(stTipo.hasMoreTokens()){
 tipo = stTipo.nextToken();

if(ENT.contains(tipo) || DEC.contains(tipo) ||
TEXT.contains(tipo)|| TAKE.contains(tipo)){
Error.setText("La Variable esta repetida ("+tipo+") "+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}

ENT.add(tipo);
}
}
if(tipo.contains("DNUM")){

while(stTipo.hasMoreTokens()){
tipo = stTipo.nextToken();

if(ENT.contains(tipo) || DEC.contains(tipo) ||
TEXT.contains(tipo)|| TAKE.contains(tipo)){
Error.setText("La Variable esta repetida ("+tipo+") "+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}

DEC.add(tipo);
}
}
if(tipo.contains("TAKE")){

while(stTipo.hasMoreTokens()){
tipo = stTipo.nextToken();
 if(ENT.contains(tipo) || DEC.contains(tipo) ||
TEXT.contains(tipo)|| TAKE.contains(tipo)){
Error.setText("La Variable esta repetida ("+tipo+") "+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}

TAKE.add(tipo);
}
}
if(tipo.contains("WORD")){

while(stTipo.hasMoreTokens()){
tipo = stTipo.nextToken();

if(ENT.contains(tipo) || DEC.contains(tipo) ||
TEXT.contains(tipo)|| TAKE.contains(tipo)){
Error.setText("La variable esta repetida ("+tipo+") "+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}

TEXT.add(tipo);
}
}
}
if(token.matches(defVal)){
StringTokenizer stComprobar = new StringTokenizer(token," \n\
t=;");
String ID = stComprobar.nextToken(), comprobar = "", tok = "";
//System.out.print(ID);
while(stComprobar.hasMoreTokens()){
comprobar += stComprobar.nextToken();
 }

if(ENT.contains(ID)){
StringTokenizer stComprobarE = new
StringTokenizer(comprobar,"+*/-");
while(stComprobarE.hasMoreTokens()){
tok = stComprobarE.nextToken();

if(tok.matches(id)){
if(ENT.contains(tok));
else{
Error.setText("ERROR SEMÁNTICO ("+tok+") "+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}
}
else{
if(tok.matches(entero));
else{
Error.setText("ERROR SEMÁNTICO ("+tok+") "+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}
}
}
}
else {
if(DEC.contains(ID)){
StringTokenizer stComprobarD = new
StringTokenizer(comprobar,"+*/-");
while(stComprobarD.hasMoreTokens()){
tok = stComprobarD.nextToken();
 if(tok.matches(id)){
if(DEC.contains(tok));
else{
Error.setText("ERROR SEMÁNTICO ("+tok+")
"+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}
}
else{
if(tok.matches(decimal));
else{
Error.setText("ERROR SEMÁNTICO ("+tok+")
"+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}
}
}
}
else {
if(TEXT.contains(ID)){
if(comprobar.matches("((((\")[.\\W\\w\\s]*(\"))|("+id+"))((\\
s)*(\\+)((\\s)*((\")[.\\W\\w\\s]*(\"))|("+id+")))*)"));
else {
Error.setText("ERROR SEMÁNTICO "+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
 errores=1;
break;
}
}
else{
Error.setText("Variable no declarada "+i+": \n"
+
"________________________________________________________________________\
n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}
}
}
}
}

else {
if(token.contains("SEND")){
txtATraducido.setText("PRINT");
Error.setText("Error al declarar sentencia SEND; en la linea "+i+": \
n"
+ "\n"+token);
errores=1;
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}
if(token.contains("NUM") || token.contains("DNUM") ||
token.contains("WORD")){
Error.setText("Error en declaracion de variables; en la linea "+i+": \
n"
+ "\n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
 }
if(token.contains("TAKE")){
Error.setText("Error en lectura de valor TAKE en la linea "+i+": \n"
+ "\n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}
if(token.contains("STOP}")){

Error.setText("Cierre de Ciclo START incorrecto en la linea "+i+": \

n"
+ "\n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}
if(token.contains("START")){

Error.setText("Inicio de Ciclo START incorrecto en la linea "+i+": \

n"
+ "\n"+token);
for(int j = 1; j <i; j++){
txt += "\n";
}
LineaError.setText(txt+" ¡!");
errores=1;
break;
}

Analizador semántico:

Empezaremos creando la ventana, donde se ejecutará el texto que pondremos, donde se

generará la tabla de índices, la detección de errores y opción para convertir un programa.

Teniendo nuestro diseño de la ventana que se utilizara para el analizador semántico,
procederemos a hacer la estructura del código.

Empezaremos con el espacio que tendremos para nosotros colocar nuestro código a
analizar.

Primero que nada, tendremos que poner las librerías que usaremos para nuestro compilador
semántico, para que pueda funcionar de manera correcta.

Procedemos a agregarlos:
Una vez agregados, editaremos el espacio del texto del archivo:
Teniendo la ventana del analizador, editaremos el código de la tabla de símbolos del
analizador semántico. Para este caso pondremos los símbolos que usaremos, juntos con las
operaciones de la tabla de símbolos.
Como vemos, iremos agregando varias condiciones que el programa ira tomando en base a
lo que se pide, en este caso, los símbolos del texto que nosotros agregaremos.

Pasamos a la parte más importante, que será, el compilador semántico que se tiene que
hacer al texto, en este caso, nos iremos al botón que creamos para el análisis semántico.
Seguiremos haciendo las operaciones básicas de la estructura del analizador semántico.
Tenemos que designar varios ciclos, ya que el compilador debe verificar de manera
adecuada, cuáles son los errores semánticos, en este caso, seguiremos agregando los ciclos
correspondientes a cada caso.
Para terminar, debemos cerrar el ciclo con la última línea del texto.

También debemos cerrar las llaves correspondientes de la clase del botón del analizador
semántico.
Una vez terminada la clase, seguiremos con los botones, en este caso, primero el campo de
texto, y el botón de la lista de errores semánticos.
Modificamos el siguiente botón del texto correspondiente.
Debemos agregar los símbolos de la estructura semántica:

Hay que tener en cuenta siempre los tokens, ya que son parte fundamental del compilador:
Vemos el correcto funcionamiento del programa:

Optimizar códigos intermedios

Las propuestas en cuanto a los siguientes códigos intermedios, nos dice que

podemos optimizar los códigos de la siguiente forma. El código máquina o el lenguaje

ensamblador permiten un control muy fino del proceso de ejecución: cómo se asignan los

registros del procesador, cómo se almacenan los datos y se accede a la memoria, … Así es

posible exprimir la máxima eficiencia de una plataforma, aunque el precio a pagar es la

falta de portabilidad y el mayor coste de desarrollo y mantenimiento del código.

Afortunadamente, hoy en día podemos utilizar lenguajes de programación de alto

nivel, que abstraen estos detalles de la plataforma y nos permiten ser más

productivos resolviendo problemas más complejos en menos tiempo. Sin embargo, con esta

transición hemos perdido algo de eficiencia… ¿o no? Quizás tampoco tanta, porque los
compiladores incorporan técnicas que permiten mejorar el rendimiento del código

generado.

La optimización de código es el conjunto de fases de un compilador que

transforman un fragmento de código en otro fragmento con un comportamiento

equivalente y que se ejecuta de forma más eficiente, es decir, usando menos recursos de

cálculo como memoria o tiempo de ejecución. Es importante destacar que:

-La condición de tener un «comportamiento equivalente» es bastante onerosa, ya

que incluye también situaciones de error donde el comportamiento debe ser el mismo.

Pongamos como ejemplo una instrucción como «x = y / y«. La tentación es substituir esta

expresión por «x =1«, pero es necesario garantizar que la variable y no puede ser igual a 0,

porque entonces el código podría tener un comportamiento diferente según el lenguaje

(p.ej. división por cero).

-También es fundamental garantizar que el código no será menos eficiente que antes

de optimizarlo. Por ejemplo, el desenrollado de bucles (loop unrolling, replicar N veces el

código de un bucle) puede reducir el tiempo de ejecución al simplificar instrucciones

innecesarias (p.ej. saltos), aunque al hacerlo puede hacer crecer el tamaño del código. Dado

que el tamaño del código puede tener consecuencias a nivel de acceso a caché y a la

memoria, podría pasar que el programa optimizado acabara siendo más lento que el

original.

Existen diferentes técnicas para optimizar el código, cada una de las cuales

intenta mejorar un aspecto diferenciado del código. En general pueden clasificarse en dos

categorías, las de flujo de datos (data-flow) y las de flujo de control (control-flow). Las

optimizaciones del flujo de datos pretenden mejorar la eficiencia de los diferentes cálculos

realizados en el programa: precalculando expresiones con valor conocido en tiempo de

compilación, reaprovechando cálculos ya realizados en otras partes del código o

suprimiendo cálculos innecesarios, …  Por contra, las optimizaciones del flujo de control

intentan utilizar las instrucciones de salto condicional e incondicional de la forma más

eficiente posible (ya sea desplazando código o eliminando saltos innecesarios). Puede

definirse también una tercera categoría, las optimizaciones de bucles (loop optimization),

intenta mejorar el rendimiento de las instrucciones iterativas como for, while … do o repeat

… until. En este caso, los cambios realizados al código del bucle afectan tanto al flujo de

datos como al flujo de control.

La ventaja de todas estas técnicas es que se aplican de forma automática cada vez

que compilamos nuestro código, de forma que podemos centrarnos en hacer nuestro código

legible en lugar de intentar optimizar «a mano». Como dijo Donald Knuth, «la

optimización prematura es la raíz de todos los males». Dejemos a los compiladores los

detalles de bajo nivel y dediquémonos a diseñar un buen algoritmo, que ya es un trabajo

suficientemente complejo.

Por ejemplo, aquí vemos un claro ejemplo de código intermedio:

public void Guardarbas()

try

j = new JFileChooser();
 j.setFileSelectionMode( JFileChooser.FILES_ONLY );

FileNameExtensionFilter filtroTxt=new FileNameExtensionFilter("Archivos

BAS","bas");

j.setFileFilter(filtroTxt);

j.setFileHidingEnabled(false);

int fin = this.getTitle().lastIndexOf('.');

if(fin == -1)fin = this.getTitle().length();

j.setSelectedFile(new File(this.getTitle().substring(0,fin)));

int select = j.showSaveDialog(this);

File guarda = j.getSelectedFile();

if(select == JFileChooser.APPROVE_OPTION)

if(guarda !=null)

FileWriter save=new FileWriter(guarda+".bas");

 save.write(txtATraducido.getText());

save.close();

JOptionPane.showMessageDialog(null,"Se ha guardado el

archivo","Información",JOptionPane.INFORMATION_MESSAGE);

catch(IOException ex)

JOptionPane.showMessageDialog(null,"Su archivo no se ha

guardado","Advertencia",JOptionPane.WARNING_MESSAGE);