/* Read me:
 Note: As I have said this program has already comments.
   	If you see this "==" sign in a comment like this "//==", 
   	it means that is my question.
*------------------------------------------------------------------------------/  
 		 
 
 
/*   
   This module contains the recursive descent  
   parser that does not use variables.  
*/  
 
// Exception class for parser errors.  
class ParserException extends Exception {  
  String errStr; // describes the error 
 
 
  public ParserException(String str) { 
    errStr = str; 
  }   
 
  public String toString() {  
    return errStr; 
  }  
}  
 
class Parser {  //==what is the concept of parser?
  // These are the token types. 
  final int NONE = 0; 		//== why NONE is initially zero
  final int DELIMITER = 1; 	//== why DELIMITER is initially to 1	
  final int VARIABLE = 2; 	//== what is purpose of these token type
  final int NUMBER = 3; 
 
  // These are the types of syntax errors. 
  final int SYNTAX = 0; 	
  final int UNBALPARENS = 1;
  final int NOEXP = 2; 		
  final int DIVBYZERO = 3; 
 
  // This token indicates end-of-expression. 
  final String EOE = "\0"; //== purpose of this and why "\0"?
  						   //== Can you explain what is end-of-expression.
 
 	//== What is exp, expIndx, token and toktype and its purpose
  private String exp;   // refers to expression string  
  private int expIdx;   // current index into the expression  
  private String token; // holds current token  
  private int tokType;  // holds token's type  
 
  // Parser entry point.  
  public double evaluate(String expstr) throws ParserException 
  {  
    double result;  
    exp = expstr;  
    expIdx = 0;   
 
 
    getToken(); 
    if(token.equals(EOE)) 
     handleErr(NOEXP); // no expression present  
 
    // Parse and evaluate the expression. 
    result = evalExp2();  //== What is parse? and why result is equals to evalExp2
 
    if(!token.equals(EOE)) // last token must be EOE  //== Meaning of this 
      handleErr(SYNTAX);  //== Why we throw to SYNTAX
 
    return result;  //== Why we return to result
  }  
 
  // Add or subtract two terms.  
  private double evalExp2() throws ParserException 
  {  
    char op;  	
    double result; 		//== why we have so many result declaration
    double partialResult; //== purpose of this, Why we have this?
 
    result = evalExp3();  //== purpose of evalExp3
 
 
 //== Meaning of chartAt(0)
    while((op = token.charAt(0)) == '+' || op == '-') {  
      getToken();  
      partialResult = evalExp3();  //==why do we need to declare partialResult is equals to evalExp3? 
      switch(op) {  //== meaning of switch adn why we switch op?
        case '-':  
          result = result - partialResult;  
          break;  
        case '+':  
          result = result + partialResult;  
          break;  
      }  
    }  
    return result; 
  }  
 
  // Multiply or divide two factors.  
  private double evalExp3() throws ParserException 
  {  
    char op;  
    double result; 
    double partialResult;  
 
    result = evalExp4();
 
    while((op = token.charAt(0)) == '*' ||  
           op == '/' || op == '%') {  
      getToken();  
      partialResult = evalExp4();  
      switch(op) {  
        case '*':  
          result = result * partialResult;  
          break;  
        case '/':  
          if(partialResult == 0.0)  
            handleErr(DIVBYZERO);  
          result = result / partialResult;  
          break;  
        case '%':  
          if(partialResult == 0.0)  
            handleErr(DIVBYZERO);  
          result = result % partialResult;  
          break;  
      }  
    }  
    return result; 
  }  
 
  // Process an exponent.  
  private double evalExp4() throws ParserException 
  {  
    double result; 
    double partialResult; 
    double ex;  
    int t;  
 
    result = evalExp5();  
 
    if(token.equals("^")) {  //== Pls elaborate this exponent
      getToken();  
      partialResult = evalExp4();  
      ex = result;  //== What we have ex
      if(partialResult == 0.0) {  
        result = 1.0;  
      } else  
        for(t=(int)partialResult-1; t > 0; t--)  //== especially this one
        //== why t-1 and t--
          result = result * ex;  
    }  
    return result; 
  }  
 
  // Evaluate a unary + or -.  
  private double evalExp5() throws ParserException 
  {  
    double result; 
    String  op;  
 
    op = "";  
    if((tokType == DELIMITER) &&  
        token.equals("+") || token.equals("-")) {  
      op = token;  
      getToken();  
 
    }  
    result = evalExp6();  
 
    if(op.equals("-")) result = -result; 
 
    return result;  
  }  
 
  // Process a parenthesized expression.  
  private double evalExp6() throws ParserException 
  {  
    double result; 
 
    if(token.equals("(")) {  
      getToken();  
      result = evalExp2();  
      if(!token.equals(")"))  
        handleErr(UNBALPARENS);  
      getToken();  
    }  
    else result = atom();  
 
    return result; 
  }  
 
  // Get the value of a number.  
  private double atom() throws ParserException  
  {  
    double result; 
 
    switch(tokType) {  
      case NUMBER:  
        try {  // What is try command
          result = Double.parseDouble(token);  
        } catch (NumberFormatException exc) {  // What happen in this line
          handleErr(SYNTAX);  
        }  
        getToken();  
        break; 
      default:  
        handleErr(SYNTAX);  
        break;  
    }  
    return result; 
  }  
 
  // Handle an error.  
  private void handleErr(int error) throws ParserException 
  {  
    String[] err = {"Syntax Error","Unbalanced Parenthesesa","No Expression Present","Division by Zero"  
    };  
 
    throw new ParserException(err[error]);  
  }  
 
  // Obtain the next token.  
  private void getToken()  
  {  
    tokType = NONE;  
    token = "";  
 
    // Check for end of expression.  
    if(expIdx == exp.length()) { 
      token = EOE; 
      return; 
    } 
 
    // Skip over white space. 
    while(expIdx < exp.length() &&  
      Character.isWhitespace(exp.charAt(expIdx))) ++expIdx;  
 
    // Trailing whitespace ends expression. 
    if(expIdx == exp.length()) { 
      token = EOE; 
      return; 
    } 
 
    if(isDelim(exp.charAt(expIdx))) { // is operator  
      token += exp.charAt(expIdx);  
      expIdx++;  
      tokType = DELIMITER;  
    }  
    else if(Character.isLetter(exp.charAt(expIdx))) { // is variable  
      while(!isDelim(exp.charAt(expIdx))) {  
        token += exp.charAt(expIdx);  
        expIdx++;  
        if(expIdx >= exp.length()) break;  
      }  
      tokType = VARIABLE;  
    }  
    else if(Character.isDigit(exp.charAt(expIdx))) { // is number  
      while(!isDelim(exp.charAt(expIdx))) {  
        token += exp.charAt(expIdx);  
        expIdx++;  
        if(expIdx >= exp.length()) break;  //== why we use break
      }  
      tokType = NUMBER;  
    }  
    else { // unknown character terminates expression 
      token = EOE; 
      return; 
    } 
  }  
 
  // Return true if c is a delimiter.  
  private boolean isDelim(char c)  //== why we have char c
  {  
    if((" +-/*%^=()".indexOf(c) != -1))  //== Meaning of this line, why != -1? 
      return true;  //== Why return to true
    return false;  
  }  
 
} 
 
 
/*== If you think I missed something in my questions that so important please let me know what it is and explain what you mean.
 
 
	 Thanks for reading....
*/

 
 
 
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
 
 
public class cal {
 
JLabel expression1 = new JLabel("Expression:");
JLabel result1 = new JLabel("Result: ");
 
 
JTextField expression_textf1 = new JTextField(22);
JTextField result_textf1 = new JTextField(10);
 
 
JButton clear1 = new JButton(" Clear ");
 
 
 
 
 
JButton calculate1 = new JButton(" Calculate");
JButton cancel1 = new JButton(" Cancel");
 
Parser p = new Parser();
 
public JPanel gui_2() {
 
JPanel northPanel1 = new JPanel();
JPanel northPanel2 = new JPanel();
 
northPanel1.setLayout(new GridLayout(2, 0));
 
northPanel1.add(expression1);
northPanel1.add(expression_textf1);
northPanel1.add(result1);
northPanel1.add(result_textf1);
 
northPanel2.setLayout(new FlowLayout(FlowLayout.CENTER));
northPanel2.add(northPanel1);
 
return northPanel2;
 
}
 
public JPanel gui_3() {
 
 
JPanel southPanel1 = new JPanel();
JPanel southPanel2 = new JPanel();
 
southPanel1.setLayout(new GridLayout(2, 2));
 
 
southPanel2.add(calculate1);
southPanel2.add(clear1);
southPanel2.add(cancel1);
 
result_textf1.setEditable(false); // Result field should not be editable
 
calculate1.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) {
		String expr = expression_textf1.getText().trim();
		try {
			result_textf1.setText(String.valueOf(p.evaluate(expr)));	
		}
		catch(ParserException exc) {
			result_textf1.setText(String.valueOf(exc));
		}
	}
});
 
clear1.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) {
		expression_textf1.setText("");
		result_textf1.setText("");
		expression_textf1.requestFocus();
	}
});
 
cancel1.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) {
		System.exit(0);
	}
});
 
southPanel2.setLayout(new FlowLayout(FlowLayout.CENTER));
southPanel2.add(southPanel1);
 
return southPanel2;
 
}
 
 
public JFrame buildNewFrame() {
 
try{
UIManager.setLookAndFeel(
UIManager.getSystemLookAndFeelClassName());
 
 
}catch(Exception e){}
 
cal re = new cal();
 
JPanel northPanel = new JPanel();
JPanel southPanel = new JPanel();
JPanel finalPanel = new JPanel();
 
northPanel = re.gui_2 ();
southPanel = re.gui_3 ();
 
 
finalPanel.setLayout( new BorderLayout());
finalPanel.add(northPanel, BorderLayout.NORTH);
finalPanel.add(southPanel, BorderLayout.SOUTH);
 
 
JFrame frame = new JFrame("Calculator");
 
frame.setSize(900, 900);
 
frame.getContentPane().add(finalPanel);
 
frame.addWindowListener( new WindowAdapter()
 
 
 
 
 
{
 
public void windowClosing( WindowEvent e) {
 
System.exit(0);
}
});
 
 
return frame;
 
 
}
 
}

 
 
 
 
import javax.swing.JFrame;
 
public class runner {
 
public static void main(String args[]){
 
JFrame lor = new JFrame();
cal rece = new cal();
lor = rece.buildNewFrame();
 
lor.pack();
lor.setVisible(true);
 
}
 
}