Parse formula

Question

Hi, all:
I am developing a salary system by using J2EE. As we know, the salary and allowance systems of various company have great differently. So I create a table to store formula. Also, I also create a salary item table to maintain salary items. When I calculate salary, I need to parse salary formula. Who has algorithms? I want a algorithm which can parse +, - *, /, ().
For example: one of salary items is:
f9 = (f10-2000)*0.8;
f1 = f2 + f3 - f4;
f1, f2, f3, ...., f9, f10 represent salary and allowance items.
Any help would be useful.
Thanks!

Answer 1

Here is the code, there are other classes refered to in this one, but you should be able to figure out what they are based on the name. If you have any questions let me know
import java.util.StringTokenizer;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
  *@author Steven Bell
  *@version 1.0 3/5/03
  *the ExpressionTree class is used to evaluate and hold a mathmatical expression
public class ExpressionTree{
     SimpleStack numberstack, opstack, cellrefs;
     String originalexpression;
     Token root;
     Graph graph;
       *creates an Expression tree
       *@param expression the expression to be evaluated
       *@param graph a reference to the Graph where cells are stored
       *@throws MalformedCellException thrown if the expression is invalid
     ExpressionTree(String expression, Graph graph)throws MalformedCellException{
          originalexpression      = expression;
          this.graph              = graph;
          StringTokenizer extoken = new StringTokenizer(expression, OperatorToken.OPERATORS, true);
          String[] tokens         = new String[extoken.countTokens()];
          for(int i=0;i<tokens.length;i++){
               tokens=extoken.nextToken();
          buildTree(tokens);
     //creates the tree from the array of tokens each token is a portion of the expression
     private void buildTree(String[] tokens)throws MalformedCellException{
          boolean checkunaryminus = true;
          boolean unaryminus = false;
          numberstack = new SimpleStack(13);
          opstack = new SimpleStack(13);
          cellrefs = new SimpleStack(13);
          for(int i=0;i<tokens.length;i++){
               if(LiteralToken.isLiteral(tokens[i])){
                    if(unaryminus){
                         numberstack.push(new LiteralToken(-1*Double.parseDouble(tokens[i])));
                         opstack.pop();
                         unaryminus = false;
                    }else{
                         numberstack.push(new LiteralToken(Double.parseDouble(tokens[i])));
                    checkunaryminus = false;
               }else if(CellToken.isCell(tokens[i])){
                    Cell tempcell = getCell(tokens[i]);
                    cellrefs.push(tempcell);
                    Token temp = new CellToken(tempcell);
                    if(unaryminus){
                         temp = buildSubTree(new LiteralToken(0), (OperatorToken)opstack.pop(), temp);
                         unaryminus = false;
                    numberstack.push(temp);
                    checkunaryminus = false;
               }else if(OperatorToken.isOperator(tokens[i])){
                    if(unaryminus) throw new MalformedCellException("illegal expression operator after minus");
                    char op = tokens[i].charAt(0);
                    if(checkunaryminus){
                         if(op=='-'){
                              opstack.push(new OperatorToken(op));
                              checkunaryminus = false;
                              unaryminus = true;
                         }else{
                              opstack.push(new OperatorToken(op));
                    }else{
                         if(op=='('){
                              opstack.push(new OperatorToken(op));
                         }else if(op==')'){
                              OperatorToken temp = (OperatorToken)opstack.pop();
                              while(temp.instancePriority() != OperatorToken.getPriority('(')){
                                   if(numberstack.numObjects()<2){
                                        throw new MalformedCellException("Incefficient Numbers");
                                   Token r = (Token)numberstack.pop();
                                   Token l = (Token)numberstack.pop();
                                   numberstack.push(buildSubTree(l, temp, r));
                                   temp = (OperatorToken)opstack.pop();
                         }else{
                              if(!opstack.isEmpty()){
                                   OperatorToken ot = (OperatorToken)opstack.peek();
                                   if(OperatorToken.getPriority(op)<ot.instancePriority()){
                                        if(numberstack.numObjects()<2){
                                             throw new MalformedCellException("Incefficient Numbers");
                                        Token r = (Token)numberstack.pop();
                                        Token l = (Token)numberstack.pop();
                                        numberstack.push(buildSubTree(l, (OperatorToken)opstack.pop(), r));
                              opstack.push(new OperatorToken(op));
                         checkunaryminus = true;
               }else{
                    throw new MalformedCellException("illegal expression Failed all tests");
          while(!opstack.isEmpty()){
               if(numberstack.numObjects()<2){
                    throw new MalformedCellException("Incefficient Numbers");
               Token r = (Token)numberstack.pop();
               Token l = (Token)numberstack.pop();
               numberstack.push(buildSubTree(l, (OperatorToken)opstack.pop(), r));
          root = (Token)numberstack.peek();
     *gets the value of this expression
     *@return String returns the value of this expression in a String
     public String getValue(){
          double temp = root.getValue();
          return String.valueOf(temp);
     *gets the original expression that was parsed
     *@return String the original expression
     public String getEquation(){
          return originalexpression;
     *get the cells that are reference in this expression
     *@return Cell[] array of cells this expression holds
     public Cell[] getReferences(){
          Cell[] returncells = new Cell[cellrefs.numObjects()];
          int index = 0;
          while(!cellrefs.isEmpty()){
               returncells[index++]=(Cell)cellrefs.pop();
          return returncells;
     //builds one three node subtree
     private Token buildSubTree(Token l, OperatorToken ot, Token r){
          ot.setLeftChild(l);
          ot.setRightChild(r);
          return ot;
     //uses buildSubTree to create a tree until more of the expression needs to be parsed
     private Token buildSubTrees(char op)throws MalformedCellException{
          if(op==')'){
               OperatorToken ot = (OperatorToken)opstack.peek();
               while(ot.instancePriority()!=0){
                    if(numberstack.numObjects()<2){
                         throw new MalformedCellException("Incefficient Numbers");
                    Token r = (Token)numberstack.pop();
                    Token l = (Token)numberstack.pop();
                    numberstack.push(buildSubTree(l, (OperatorToken)opstack.pop(), r));
          }else{
               OperatorToken ot = (OperatorToken)opstack.peek();
               while(OperatorToken.getPriority(op)<ot.instancePriority()){
                    if(numberstack.numObjects()<2){
                         throw new MalformedCellException("Incefficient Numbers");
                    Token r = (Token)numberstack.pop();
                    Token l = (Token)numberstack.pop();
                    numberstack.push(buildSubTree(l, (OperatorToken)opstack.pop(), r));
          return (Token)numberstack.peek();
     //gets or creates cell that is referenced in expression
     private Cell getCell(String cellname)throws MalformedCellException{
          int row = 0;
          int col = 0;
          Pattern colpatt = Pattern.compile("[a-zA-Z]+");
          Pattern rowpatt = Pattern.compile("\\d+");
          Matcher m = colpatt.matcher(cellname);
          m.find();
          String columnstring = m.group().toUpperCase();
          m = rowpatt.matcher(cellname);
          m.find();
          String rowstring = m.group();
          row = Integer.parseInt(rowstring);
          row--;
          char[] colchar = columnstring.toCharArray();
          for(int j=colchar.length-1;j>=0;j--){
               col+=colchar[j]-'A'*Math.pow(26, j);
          if(row<0||col<0){
               throw new MalformedCellException("illegal expression");
          Vertex v = graph.doesCellExist(col, row);
          if(v!=null){
               return v.getCell();
          return new Cell(col, row, "0", graph);