Configurando el debug para DosBox modo persistente

DosBox configurado para arranque el debug

Despues de haber visto, el anterior (aqui para ver anterior post) hoy procederemos a configurar nuestro DosBox de modo que no tengamos que estar montando cada vez que lo iniciemos.

Primero debemos entrar al archivo de configuración del dosbox

• Para acceder desde windows 8 tendriamos algo asi cómo

• Para acceder desde windows xp, w7

En ambos casos debemos abrir el DOSBox 0.74 option y tendremos abierto un archivo como este

Buscamos la seccion [autoexec] 

suponiendo que tenemos la carpeta del debug125 en la ruta(D:\install\debug125)  si quieres descargar debug125 ingresa aqui

mount y: "D:\install\Debug125"
set path=%path%;
y:

y voila ya tenes de modo persistente configurado nuestro dos box que hicimos con esa linea
en la primera linea montamos la ruta del debug, en la segunda le indicamos al prompt donde puede buscar en este caso la y que es la unidad donde esta la carpeta debug y en la ultima linea cambiamos de unidad.

Calculadora Estandar

Calculadora Estandar

Esta pequeña aplicacion que realize esta en google play

Puedes descargala desde aqui 

Esta un poco tosca pero ire mejorandola solo es la parte gráfica que un post anterior(ver post), mostre el código de la parte lógica

Debug en DosBox

DEBUG

Esta vez vamos a ver como utilizar el debug pero para no tener muchos problemas necesitamos un emulador, en este caso vamos a utilizar el DOSBOX excelente emulador de DOS, podriamos utilizar otro emulador como virtual box u otro, pero tendria que realizar la instalación de dicho sistema operativo,

Bueno empezaremos desde cero, primeramente descargamos el dosbox y le damos instalar

Descargar de aqui( DosBox 0.74 win32)

La instalación es sumamente sencilla solo siguiente siguiente

Una vez ya instalado el DosBox procedemos a preparar el debug para eso necesitamos el debug

aqui tenemos un clon del debug http://www.japheth.de/debxxf.html

Descargar debug

Montando el debug 

Magnifico, hasta aqui ya tiene las herramientas, ahora procedemos a configurar para eso debemos descomprimir la carpeta debug125 y la montamos en nuestro dosbox

Suponiendo que tenemos descomprimido en esta direccion(D:\Install\DEBUG125) el debug 

Ejecutamos el dos box  y ejecutamos el siguiente comando

mount y: "D:\Install\DEBUG125"

donde y: seria nuestra unidad que aparecera dentro del dosbox y la carpeta debug125 sera la carpeta a montar 

y luego presionar enter asegurar de que recibamos el siguiente mensaje (Drive Y is mounted as local directory )

Si obtiene otro mensaje asegurate de que la ruta existe, y voila ya tenemos nuestro dosbox configurado para poder trabajar con el debug,

Bueno ahora solo hacemos el cambio de unidad en el dos para los novatos del DOS esto se realiza 

con el siguiente comando

y:

y luego ejecutamos el comando debug

debug

Hasta aqui ya podemos utilizar el debug.El debug es un excelente programa para aprender el lenguaje ensamblador porque en el sistema DOS tenemos un control total por eso le recomiendo que utilicen el DOS ya que en otros sistemas operativos como xp, existe proteccion de memoria para los programas.

 El unico problema de configuración que tenemos es que cada vez que ejecutemos el dosbox necesita montar la ruta donde esta el debug, pues no se guarda porteriormente les explicare como hacer que la montada sea persistente ademas necesitamos ejecutar el debug desde cualquier otra unidad, 

Calculadora

Esta calculadora es una aplicación de uso de pilas y colas, la misma que utiliza la notación postfija para realizar el calculo, lo hice hace bastante tiempo, la misma que esta estructurada en 4 clases

1 Clase Cola

2 Clase Pila

3 ConversionAritmetica

4 Calculadora

1.- Clase Cola.- Representa una estructura FIFO (primero en entrar primero en salir)

public class Cola {
 int Frente, Atras;
 int maxx = 50;
 String[] v = new String[maxx];

 Cola() {
  Frente = Atras = -1;
 }

 public boolean vacia() {
  return ((Frente == -1) && (Atras == -1));
 }

 public boolean llena() {
  int Atras1 = Atras;
  Atras1++;
  if (Atras1 > maxx) {
   Atras1 = 0;
  }
  return (Atras1 == Frente);
 }

 public void meter(String x) {
  if (llena()) {
   System.out.print("cola llena");
   System.exit(0);
  } else {
   if (Atras == -1) {
    Frente = Atras = 0;
   } else {
    Atras++;
    if (Atras > maxx)
     Atras = 0;

   }
  }
  v[Atras] = x;
 }

 public String sacar() {
  if (vacia()) {
   System.out.print("cola vacia");
   System.exit(0);
  } else {
   String x = v[Frente];
   if (Frente == Atras)
    Frente = Atras = -1;

   else {
    Frente++;
    if (Frente > maxx)
     Frente = 0;

   }
   return x;
  }
  return ("no hay");
 }

 public String cabeza() {
  if (vacia()) {
   System.out.print("cola vacia");
   System.exit(0);
  }
  return v[Frente];
 }

 public int cant() {
  if (vacia()) {
   return (0);
  } else {
   if (Atras >= Frente) {
    return ((Atras - Frente) + 1);
   } else {
    return (((Atras - 0) + 1) + (maxx - Frente) + 1);
   }
  }
 }

 public void borrar() {
  if (vacia()) {
   System.out.print("la pila esta vacia");
   System.exit(0);
  } else {
   Atras--;
  }
 }

 public static void main(String arg[]) {
  Cola p = new Cola();
  p.meter("1");
  p.meter("2");
  p.meter("3");
  p.meter("4");
  p.meter("5");
  p.meter("6");
  p.meter("7");
  p.meter("8");
  p.meter("9");

  // System.out.println(p.cant());
  while (!p.vacia())
   System.out.println(p.sacar());
 }
}

2.- Clase Pila .- Cola Representa una estructura LIFO (Ultimo en entrar y primero en salir)

public class Pila {
 int n;
 int maxx = 50;
 String v[] = new String[maxx];

 public Pila() {
  n = -1;
 }

 public boolean vacia() {
  return (n == -1);
 }

 public boolean llena() {
  return (n == (maxx + 1));
 }

 public void push(String x) {
  if (llena()) {
   System.out.print("la pila se encuentra llena");
   System.exit(0);
  } else {
   n++;
   v[n] = x;

  }
 }

 public String pop() {
  if (vacia()) {
   System.out.print("la pila esta vacia");
   System.exit(0);
  } else {
   String x = v[n];
   n--;
   // System.out.println("-------- "+n);
   return x;
  }
  return "no hay";
 }

 public String cima() {
  if (vacia()) {
   System.out.print("la pila esta vacia");
   System.exit(0);
  }
  return (v[n]);
 }

 public int cant() {
  return (n + 1);
 }

 public void borrar() {
  if (vacia()) {
   System.out.print("la pila esta vacia");
   System.exit(0);
  } else {
   n--;
  }
 }

 public static void main(String arg[]) {
  Pila p = new Pila();
  p.push("1");
  p.push("2");
  p.push("3");
  p.push("4");
  p.push("5");
  p.push("6");
  p.push("7");
  p.push("8");
  p.push("9");

  // System.out.println(p.cant());
  while (!p.vacia())
   System.out.println(p.pop());
 }

};

3.- Conversion Aritmetica. Esta clase  es la que nos permite  realizar el cálculo, de una expresion

para eso hace pasos intermedio  como el de convertirlo de notación infija a postfija y posteriormente evaluar la expresion.

class ConversionAritmetica {

 Pila signo, result;
 Cola expresion, postfija;
 String exp;

 public ConversionAritmetica() {
  expresion = new Cola();
  postfija = new Cola();
  signo = new Pila();
  result = new Pila();
 }

 private void cargarToken() {
  int dim = exp.length();
  int i = 0;
  
  StringTokenizer to = new StringTokenizer(exp, " ^+*-/()", true);
  while (to.hasMoreElements()) {
   String t = to.nextToken();
   expresion.meter(t);
   // System.out.println(t);
  }
 }

 public void setExpresion(String exp) {
  this.exp = exp;
  cargarToken();
 }

 public String getExpresion() {
  return exp;
 }

 public void aPostfija() {
  String tok = "";
  averiguar();
  while (!expresion.vacia()) {
   tok = expresion.sacar();
   if (esNumero(tok))
    postfija.meter(tok);
   else if (tok.equals("("))
    signo.push(tok);
   else if (tok.equals(")")) {
    while (!signo.vacia() && (!signo.cima().equals("("))) {
     tok = signo.pop();
     postfija.meter(tok);
    }
    signo.pop();// sacamos parentesis
   } else {
    while ((!signo.vacia())
      && (prescedencia(tok) <= prescedencia(signo.cima()))
      & (!tok.equals("("))) {
     String tok1 = signo.pop();
     postfija.meter(tok1);
    }
    signo.push(tok);
   }
  }
  while (!signo.vacia()) {
   tok = signo.pop();
   postfija.meter(tok);
  }

 }

 public float valor() {
  String tok = "";
  aPostfija();
  while (!postfija.vacia()) {
   tok = postfija.sacar();
   if (esNumero(tok))
    result.push(tok);
   else {
    String num2 = result.pop();
    String num1 = result.pop();
    String r = operar(Float.parseFloat(num1),
      Float.parseFloat(num2), tok.charAt(0));
    result.push(r);
   }
  }
  return Float.parseFloat(result.pop());
 }

 public String operar(float num1, float num2, char o) {
  float valor = num1;
  switch (o) {
  case '+':
   valor += num2;
   break;
  case '-':
   valor -= num2;
   break;
  case '*':
   valor *= num2;
   break;
  case '/':
   valor /= num2;
   break;
  case '^':
   valor = (float) Math.pow(num1, num2);
   break;

  }
  return String.valueOf(valor);
 }

 private boolean esNumero(String num) {
  boolean sw = false;
  int i = 0;

  try {
   Float.parseFloat(num);
   sw = true;
  } catch (java.lang.NumberFormatException e) {
   sw = false;
  }

  
  return sw;

 }

 private boolean perteneceANumero(char n) {
  boolean sw = false;
  switch (n) {
  case '0':
  case '1':
  case '2':
  case '3':
  case '4':
  case '5':
  case '6':
  case '7':
  case '8':
  case '9':
  case '.':
   sw = true;
   break;
  }
  return sw;

 }

 private void averiguar() {
  String v[] = new String[expresion.cant()];
  int i = 0;
  for (i = 0; i < v.length; i++) {
   v[i] = expresion.sacar();
  }

  i = 0;
  if (v[i].equals("-") && (esNumero(v[i + 1]))) {
   // expresion.meter("-"+v[i+1]);
   v[i + 1] = "-" + v[i + 1];
   i = 1;
  }

  String tok = v[i];
  while (i < v.length - 1) {
   if ((!esNumero(v[i])) && (!v[i].equals(")"))
     && (v[i + 1].equals("-"))) {// (-2
    expresion.meter(v[i]);
    // v[i+1]="_";
    v[i + 2] = "-" + v[i + 2];
    i++;// porque ignoramos este caracter
   } else if (esNumero(v[i]) && (v[i + 1].equals("("))) {// 2(
    expresion.meter(v[i]);
    expresion.meter("*");
   } else if (v[i].equals(")") && (v[i + 1].equals("("))) {// )(
    expresion.meter(v[i]);
    expresion.meter("*");
   }
   
   else {
    expresion.meter(v[i]);
   }
   i++;
  }
  expresion.meter(v[i]);
  

 }

 private int prescedencia(String op) {
  int valor = 0;
  if (op.equals("+"))
   valor = 1;
  if (op.equals("-"))
   valor = 1;
  if (op.equals("*"))
   valor = 2;
  if (op.equals("/"))
   valor = 2;
  if (op.equals("^"))
   valor = 3;
  return valor;
 }

 private boolean esOperador(char op) {
  boolean sw = false;
  switch (op) {
  case '+':
  case '-':
  case '*':
  case '/':
  case ')':
  case '(':
  case '^':
   sw = true;
   break;
  }
  return sw;
 }

 public static void main(String arg[]) {
  ConversionAritmetica c = new ConversionAritmetica();
  String s = null;
  String s1 = "34*5+6*(3^2)";
  s1 = "(5^1)(-2)(-2)(3+1)+0(-2)";
  // s1="-5+2";//="(((6^2)))((3-1))";
  c.setExpresion(s1);
  System.out.println(c.valor());
  Cola p = c.expresion;
  /*
   * if(p.vacia()) System.out.println("vacia"); while(!p.vacia()){
   * System.out.println(p.sacar()); }
   */
 }

}

Habrás notado que cada clase tiene un main pero solo era para probar si funcionaba bién o testear a cada clase. Y Con todo eso ya tenemos la lógica de la calculadora lo que no hace falta es la gráfica y eso se lo dejo para mi querido lector.