section	.text
   global _start 		;parida que necesita el linker xD
 
_start:					;entry point
        pop	ebx
        pop	ebx
        pop	ebx
        pop	ebx
        mov	eax,5
        add     ebx,ecx
	mov	edx,len	;Longitud del mensaje
	mov	ecx,msg	;Mensaje que vamos a escribir
	mov	ebx,1	;file descriptor (stdout)
	mov	eax,4	;llama de sistema numero 4 (sys_write)
	int	80h	;call al kernel para que ejecute las sentencias
        pushad ;Guardamos registros
        pushfd ;Guardamos flags
        mov     eax, 3 ;sys_read(3)
        mov     ebx, 0 ;stdin (0)
        mov     ecx, esi ;Guardamos la string en esi
        mov     edx, 1 ;nnumero de bytes a leer
        int     80h ;llamada al kernel de linux
        popfd ;re-establecemos flags
        popad ;re-establecemos registros
        ret ;retorno para llamar al procedimiento
 
        mov	edx,length2	;longitud del mensaje
	mov	ecx,esi	;mensaje a escribir
        mov	ebx,1	;file descriptor (stdout)
        mov	eax,4	;llamada a sistema numero 4 (sys_write)
	int	80h	;linux esta aqui!
        mov     eax,1	;llamada a sistema numero 1 (sys_exit)
	int	80h	;llamada al kernel, linux acabará con la ejecución del proceso
 
 
 
section	.data
 
msg	db	'Hola mundo!',10	;la primera cadena
mensaje2 db 'a',10
len	equ	$ - msg			;longitud de nuestra cadena
length2 equ  $ - mensaje2
 

section	.text
   global _start 		;parida para tener al linker contento
 
_start:					;entry point
 
	mov	edx,len	;colocamos en edx como primer argumento de la llamada a sys_write len
	mov	ecx,msg	;en ecx el segundo argumento que es una define double word (la cadena)
	mov	ebx,1	;el file descriptor, el out standard
	mov	eax,4	;llamada a sistema (sys_write)
	int	80h	;llamamos al kernel para que ejecute
        jmp segundaLlamada ;salto incondicional a otra seción de codigo
 
segundaLlamada:
 
        mov	edx,length2	;lo mismo de antes
	mov	ecx,mensaje2	;lo mismo
	mov	ebx,1	;lo mismo
	mov	eax,4	;mas de lo mismo
	int	80h	;mas todavia
        mov	eax,1	;llamamos a 1 (sys_exit)
        mov ebx,0       ;codigo de salida, o eso he entendido
	int	80h	;otra vez mi querido linux
 
section	.data
 
msg	db	'Hola mundo!',10	;cadena
mensaje2 db 'Y buenos dias NASM',10
len	equ	$ - msg			;cadena
length2 equ  $ - mensaje2
 

package main;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
 
import net.java.dev.eval.Expression;
 
public class principal {
	//Por cutre que parezca, si he metido el abecedario en una matriz para identificar incognitas...
	//xD
	public static char[] TokensVariables = {'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F', 'g', 'G', 'h', 'H', 'i', 'I', 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'p', 'P', 'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'u', 'U', 'v', 'V', 'w', 'W', 'x', 'X', 'y', 'Y', 'z', 'Z'};
	public static int cuantasVariables = 0;
	public static Vector<Character> vectorOperandos = new Vector(10, 5);
	public static Vector<Character> vectorVariables = new Vector(10, 5);
 
public static void main(String args[])
{
 
	   String expresion = new String("2*x+b");
 
	   System.out.println("\n"+Procesador(preProcesador(expresion), expresion)); //La recursividad es inutil aqui, o quizas lo soy yo...
 
}
static int[] preProcesador(String argumento)
{
	char[] TokensOperandos = {'+', '-', '*', '/', '^'};
 
	char[] TokensVariables = {'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F', 'g', 'G', 'h', 'H', 'i', 'I', 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'p', 'P', 'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'u', 'U', 'v', 'V', 'w', 'W', 'x', 'X', 'y', 'Y', 'z', 'Z'};
 
	int countOperandos = 0;
	int countVariables = 0;
	/*BUCLE SEPARADOR DE OPERANDOS*/
 
	/*-NOTA: ESTE ALGORITMO SE PUEDE MEJORAR, PUES EL BUCLE SOBRECARGA*/
	//                                        ^ 
	//                                        |
	//La pereza hace cosas muy malas...  -----|
	//Bucle que busca operandos y los distribuye en memoria
	for(int i = 0; i< argumento.length(); i++)
	{
		//Bucle para recorrer la matriz con los tokens
		for(int j = 0; j < TokensOperandos.length; j++)
		{
			char chVolatil = TokensOperandos[j]; //Un caprichito de programador idiota :P
		if(argumento.charAt(i) == chVolatil)
		{
			vectorOperandos.add(chVolatil);
			countOperandos++;
		}
		}
	}
	/*BUCLE PARA SEPARAR VARIABLES                                    */
	/*-NOTA: ESTE ALGORITMO SE PUEDE MEJORAR, PUES EL BUCLE SOBRECARGA*/
    //                                        ^ 
	//                                        |
	//La pereza hace cosas muy malas...  -----|
	for(int i = 0; i < argumento.length(); i++)
	{
		//Bucle para recorrer la matriz con los tokens
		for(int j = 0; j < TokensVariables.length; j++)
		{
			char varVolatil = TokensVariables[j]; //Un caprichito de programador idiota :P
		if(argumento.charAt(i) == varVolatil)
		{
			vectorVariables.add(varVolatil);
			countVariables++;
		}
		}
	}//Que poco me gusta trabajar, y como se nota el copypaste de este fragmento...
	 //Para que codearlo 2 veces? Es inutil hacerlo :P
	System.out.print("Estos son los " + vectorOperandos.size() + " operandos que hay en la expresion:\n" );
	System.out.print("[");
	for(int i=0; i<vectorOperandos.size(); i++){
		if(i == 0)
		{
        System.out.print(vectorOperandos.elementAt(i));
		}else{
	    System.out.print(","+vectorOperandos.elementAt(i));
		}
    }
	System.out.print("]\n");
    System.out.println("/////////////////////////////////////////////////////////////////////////////// ");
    System.out.println("############################################################################### ");
    System.out.println("/////////////////////////////////////////////////////////////////////////////// ");
	System.out.print("Y aqui estan las " + vectorVariables.size() + " variables o incognitas de la expresion:\n");
	System.out.print("[");
	for(int i=0; i<vectorVariables.size(); i++){
		if(i == 0)
		{
        System.out.print(vectorVariables.elementAt(i));
		}else{
	    System.out.print(","+vectorVariables.elementAt(i));
		}
    }
	System.out.print("]");
	int[] salida = {countOperandos, countVariables};
	return salida;
}
static BigDecimal Procesador(int[] cuantos, String que)
{
 
	 Expression exp = new Expression(que);
	 InputStreamReader isr = new InputStreamReader(System.in);
     BufferedReader br = new BufferedReader(isr);
 
	 Map<String, BigDecimal> variables = new HashMap<String, BigDecimal>();
 
	 for(int j = 0; j < cuantos[1]; j++)
	 {
		 System.out.print("\nDame un valor para la variable " + vectorVariables.elementAt(j) + " :\n");
		 try {
			String expresionVolatil = br.readLine();
            variables.put(String.valueOf(vectorVariables.elementAt(j)), Procesador(preProcesador(expresionVolatil), expresionVolatil));
		} catch (IOException e) {
           e.printStackTrace();
		}
		}
     BigDecimal result = exp.eval(variables);
 
	 return result;
}
}
 
 

package equlator;
 
/**
 *
 * @author root
 */
public class Main {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        String operacion = new String("1+5");
 
        //procesador(operacion);
 
    }
    public static int procesador(String proceso)
    {
        //Variable de instancia donde quedara definida la operacion convertida a string
       int procesado = 0;
       //Matriz de caracteres de toda la cadena procesada
       char[] matrizCaracteres = proceso.toCharArray();
        int[] bufferAritmetico = null;
        System.out.println("Procesando expresion aritmetico-algebraica....");
       for(int a = 0; a < proceso.length(); a++)
       {
           System.out.println(matrizCaracteres[a]);
           if(Character.toString(matrizCaracteres[a]).equals("+") || 
              Character.toString(matrizCaracteres[a]).equals("*") || 
              Character.toString(matrizCaracteres[a]).equals("/") || 
              Character.toString(matrizCaracteres[a]).equals("-"))
           {
             if(Character.toString(matrizCaracteres[a]).equals("+"))
             {
               bufferAritmetico[a] = +; 
             }else{
 
             }
 
 
 
 
           }else{
           bufferAritmetico[a] = Integer.parseInt(Character.toString(matrizCaracteres[a]).trim());
           }
           }
           System.out.println(bufferAritmetico);
       return procesado;
    }
 
}

<html>
 
<head><title>Prueba JSP</title></head>
 
<body>
<%! public int secion = 0;%>
<%
out.println("Bienvenido a mi web<br/>");
 
out.println("<b>Pagina de ejemplo JSP</b>");
out.println("<br/>");
switch(secion)
{
case 0:
out.println("Has cojido la uno!");
break;
case 1:
out.println("Has cojido la dos!");
break;
}
 
%>
<br/>
Fecha actual: <%= new java.util.Date() %>
 
 
 
</body>
 
</html>