Avik's latest formula patches

PR:
Obtained from:
Submitted by:
Reviewed by:


git-svn-id: https://svn.apache.org/repos/asf/jakarta/poi/trunk@352498 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/poi/hssf/record/FormulaRecord.java

@@ -78,7 +78,7 @@ public class FormulaRecord
     implements CellValueRecordInterface, Comparable
 {
     
-    public static final boolean EXPERIMENTAL_FORMULA_SUPPORT_ENABLED=false;
+    public static final boolean EXPERIMENTAL_FORMULA_SUPPORT_ENABLED=true;
     
     public static final short sid =
         0x06;   // docs say 406...because of a bug Microsoft support site article #Q184647)
@@ -359,11 +359,10 @@ public class FormulaRecord
         LittleEndian.putShort(data, 18 + offset, getOptions());
         LittleEndian.putInt(data, 20 + offset, field_6_zero);
         LittleEndian.putShort(data, 24 + offset, getExpressionLength());
+        serializePtgs(data, 26+offset);
         } else {
             System.arraycopy(all_data,0,data,offset,all_data.length);
         }
-
-        // serializePtgs(data, 26+offset);
         return getRecordSize();
     }
 

src/java/org/apache/poi/hssf/record/formula/AddPtg.java

@@ -141,6 +141,7 @@ public class AddPtg
         return buffer.toString();
     }
     
+    
     public int getPrecedence() {
         return 5;
     }
@@ -149,6 +150,18 @@ public class AddPtg
         return 1;
     }
 
+    
+    public String toFormulaString(String[] operands) {
+        StringBuffer buffer = new StringBuffer();
+
+        buffer.append(operands[ 0 ]);
+        buffer.append("+");
+        buffer.append(operands[ 1 ]);
+        return buffer.toString();
+    }
+    
+
+    
     public void manipulate(List source, List results, int pos) {
         standardBinaryManipulation(source,results,pos);
         

src/java/org/apache/poi/hssf/record/formula/AttrPtg.java

@@ -210,5 +210,12 @@ public class AttrPtg
     public void manipulate(List source, List results, int pos) {
     }
     
+    public String toFormulaString(String[] operands) {
+        return "SUM(" + operands[ 0 ] + ")";
+    }    
+    
+    public int getPrecedence() {
+        return 1;
+    }    
     
 }

src/java/org/apache/poi/hssf/record/formula/DividePtg.java

@@ -120,6 +120,24 @@ public class DividePtg
         return buffer.toString();
     }
 
+     public int getPrecedence() {
+        return 4;
+    }
+    
+    public int getStringLength() {
+        return 1;
+    }
+    
+    public String toFormulaString(String[] operands) {
+        StringBuffer buffer = new StringBuffer();
+
+        buffer.append(operands[ 0 ]);
+        buffer.append("/");
+        buffer.append(operands[ 1 ]);
+        return buffer.toString();
+    }
+    
+
     public void manipulate(List source, List results, int pos) {
     }
     

src/java/org/apache/poi/hssf/record/formula/FormulaParser.java

@@ -60,56 +60,66 @@ import java.util.List;
 import java.util.ArrayList;
 import java.util.Stack;
 
+import org.apache.poi.hssf.usermodel.*;
+import java.io.FileOutputStream;
+
 /**
- * EXPERIMENTAL code to parse formulas back and forth between RPN and not
+ * EXPERIMENTAL 
  *
- * @author Avik Sengupta <lists@aviksengupta.com>
+ * @author Avik Sengupta <avik AT Avik Sengupta DOT com>
+ *
+ * This class parses a formula string into a List of tokens in RPN order
+ * Inspired by 
+ *           Lets Build a Compiler, by Jack Crenshaw
+ * BNF for the formula expression is :
+ * <expression> ::= <term> [<addop> <term>]*
+ * <term> ::= <factor>  [ <mulop> <factor ]*
+ * <factor> ::= <number> | (<expression>) | <cellRef> 
  */
 public class FormulaParser {
     
     private String formulaString;
     private int pointer=0;
     
-    private Stack operationsList = new java.util.Stack();
+    private List tokens = new java.util.Stack();
-    private Stack operandsList = new java.util.Stack();
+    //private Stack tokens = new java.util.Stack();
     private List result = new ArrayList();
     private int numParen;
     
-    //{--------------------------------------------------------------}
-    //{ Constant Declarations }
-    
     private static char TAB = '\t';
     private static char CR = '\n';
     
-    //{--------------------------------------------------------------}
+   private char Look;              // Lookahead Character 
-    //{ Variable Declarations }
     
-    private char Look;              //{ Lookahead Character }
     
+    /** create the parser with the string that is to be parsed
+     *    later call the parse() method to return ptg list in rpn order
+     *    then call the getRPNPtg() to retrive the parse results
+     *  This class is recommended only for single threaded use
+     *  The parse and getPRNPtg are internally synchronized for safety, thus
+     *  while it is safe to use in a multithreaded environment, you will get long lock waits.  
+     */
     public FormulaParser(String formula){
         formulaString = formula;
         pointer=0;
     }
     
-    //{--------------------------------------------------------------}
-    //{ Read New Character From Input Stream }
 
+    /** Read New Character From Input Stream */
     private void GetChar() {
         Look=formulaString.charAt(pointer++);
-        System.out.println("Got char: "+Look);
+        //System.out.println("Got char: "+Look);
     }
     
-    //{--------------------------------------------------------------}
-    //{ Report an Error }
 
+    /** Report an Error */
     private void Error(String s) {
         System.out.println("Error: "+s);
     }
     
     
-    //{--------------------------------------------------------------}
-    //{ Report Error and Halt }
  
+    /** Report Error and Halt */
     private void Abort(String s) {
         Error(s);
         //System.exit(1);  //throw exception??
@@ -117,61 +127,50 @@ public class FormulaParser {
     }
     
     
-    //{--------------------------------------------------------------}
-    //{ Report What Was Expected }
 
+    /** Report What Was Expected */
     private void Expected(String s) {
         Abort(s + " Expected");
     }
     
     
-    //{--------------------------------------------------------------}
-    //{ Recognize an Alpha Character }
  
+    /** Recognize an Alpha Character */
     private boolean IsAlpha(char c) {
         return Character.isLetter(c);
-        //return  UpCase(c) in ['A'..'Z'];
     }
     
     
-    //{--------------------------------------------------------------}
-    //{ Recognize a Decimal Digit }
  
+    /** Recognize a Decimal Digit */
     private boolean IsDigit(char c) {
-        System.out.println("Checking digit for"+c);
+        //System.out.println("Checking digit for"+c);
         return Character.isDigit(c);
-        
-        //return ("0123456789".indexOf( (int) c) != 0)//c in ['0'..'9'];
     }
     
     
-    //{--------------------------------------------------------------}
-    //{ Recognize an Alphanumeric }
 
+    /** Recognize an Alphanumeric */
     private boolean  IsAlNum(char c) {
         return  (IsAlpha(c) || IsDigit(c));
     }
     
     
-    //{--------------------------------------------------------------}
-    //{ Recognize an Addop }
 
+    /** Recognize an Addop */
     private boolean IsAddop( char c) {
         return (c =='+' || c =='-');
     }
     
 
-    //{--------------------------------------------------------------}
+    /** Recognize White Space */
-    //{ Recognize White Space }
-    
     private boolean IsWhite( char c) {
         return  (c ==' ' || c== TAB);
     }
     
     
-    //{--------------------------------------------------------------}
-    //{ Skip Over Leading White Space }
 
+    /** Skip Over Leading White Space */
     private void SkipWhite() {
         while (IsWhite(Look)) {
             GetChar();
@@ -179,9 +178,8 @@ public class FormulaParser {
     }
     
     
-    //{--------------------------------------------------------------}
-    //{ Match a Specific Input Character }
 
+    /** Match a Specific Input Character */
     private void Match(char x) {
         if (Look != x) {
             Expected("" + x + "");
@@ -192,9 +190,7 @@ public class FormulaParser {
     }
     
     
-    //{--------------------------------------------------------------}
+    /** Get an Identifier */
-    //{ Get an Identifier }
-    
     private String GetName() {
         String Token;
         Token = "";
@@ -211,9 +207,7 @@ public class FormulaParser {
     }
     
     
-    //{--------------------------------------------------------------}
+    /** Get a Number */
-    //{ Get a Number }
-    
     private String GetNum() {
         String Value ="";
         if  (!IsDigit(Look)) Expected("Integer");
@@ -225,138 +219,119 @@ public class FormulaParser {
         return Value;
     }
 
-    
+    /** Output a String with Tab */
-    //{--------------------------------------------------------------}
-    //{ Output a String with Tab }
-    
     private void  Emit(String s){
         System.out.print(TAB+s);
     }
 
-    
+    /** Output a String with Tab and CRLF */
-    //{--------------------------------------------------------------}
-    //{ Output a String with Tab and CRLF }
-    
     private void EmitLn(String s) {
         Emit(s);
         System.out.println();;
     }
     
-    
+    /** Parse and Translate a Identifier */
-    //{---------------------------------------------------------------}
-    //{ Parse and Translate a Identifier }
-    
     private void Ident() {
         String Name;
         Name = GetName();
         if (Look == '('){
+            //This is a function 
             Match('(');
-            //Expression() -- add this!
+            int numArgs = Arguments(); 
             Match(')');
             //this is the end of the function
-            //EmitLn("BSR " + Name);
+            tokens.add(new DummyFunctionPtg(Name,numArgs));
         } else {
-            //EmitLn("MOVE " + Name + "(PC),D0b");
             //this can be either a cell ref or a named range !!
             
             boolean cellRef = true ; //we should probably do it with reg exp??
             if (cellRef) {
-                operationsList.add(new ValueReferencePtg()); //TODO we need to pass in Name somewhere
+                tokens.add(new ValueReferencePtg()); //TODO we need to pass in Name somewhere??
             }else {
                 //handle after named range is integrated!!
             }
         }
     }
     
+    /** get arguments to a function */
+    private int Arguments() {
+        int numArgs = 0;
+        if (Look != ')')  {
+            numArgs++; 
+            Expression();
+        }
+        while (Look == ',') {
+            Match(',');
+            Expression();
+            numArgs++;
+        }
+        return numArgs;
+    }
 
-    //{---------------------------------------------------------------}
+   /** Parse and Translate a Math Factor  */
-    //{ Parse and Translate a Math Factor }
-    
-    //procedure Expression; Forward;
-    
     private void Factor() {
         if (Look == '(' ) {
             Match('(');
-            operationsList.add(new ParenthesisPtg());
             Expression();
             Match(')');
-            operationsList.add(new ParenthesisPtg());
+            tokens.add(new ParenthesisPtg());
             return;
         } else if (IsAlpha(Look)){
             Ident();
         }else{
-            //EmitLn("MOVE #" + GetNum() + ",D0");
+
             IntPtg p = new IntPtg();
             p.setValue(Short.parseShort(GetNum()));
-            operandsList.add(p);
+            tokens.add(p);
         }
     }
 
     
-    //{--------------------------------------------------------------}
+    /** Recognize and Translate a Multiply */
-    //{ Recognize and Translate a Multiply }
-    
     private void Multiply(){
         Match('*');
         Factor();
-        operationsList.add(new MultiplyPtg());
+        tokens.add(new MultiplyPtg());
-        //EmitLn("MULS (SP)+,D0");
+  
     }
     
     
-    //{-------------------------------------------------------------}
+    /** Recognize and Translate a Divide */
-    //{ Recognize and Translate a Divide }
-    
     private void Divide() {
         Match('/');
         Factor();
-        operationsList.add(new DividePtg());
+        tokens.add(new DividePtg());
-        //EmitLn("MOVE (SP)+,D1");
+
-        //EmitLn("EXS.L D0");
-        //EmitLn("DIVS D1,D0");
     }
     
     
-    //{---------------------------------------------------------------}
+    /** Parse and Translate a Math Term */
-    //{ Parse and Translate a Math Term }
-    
     private void  Term(){
         Factor();
         while (Look == '*' || Look == '/' ) {
-            //EmitLn("MOVE D0,-(SP)");
             ///TODO do we need to do anything here??
             if (Look == '*') Multiply();
             if (Look == '/') Divide();
         }
     }
     
-    
+    /** Recognize and Translate an Add */
-    //{--------------------------------------------------------------}
-    //{ Recognize and Translate an Add }
-    
     private void Add() {
         Match('+');
         Term();
-        //EmitLn("ADD (SP)+,D0");
+        tokens.add(new AddPtg());
-        operationsList.add(new AddPtg());
     }
     
     
-    //{-------------------------------------------------------------}
+    /** Recognize and Translate a Subtract */
-    //{ Recognize and Translate a Subtract }
-    
     private void Subtract() {
         Match('-');
         Term();
-        operationsList.add(new SubtractPtg());
+        tokens.add(new SubtractPtg());
-        //EmitLn("SUB (SP)+,D0");
-        //EmitLn("NEG D0");
     }
     
     
-    //{---------------------------------------------------------------}
+    /** Parse and Translate an Expression */
-    //{ Parse and Translate an Expression }
-    
     private void Expression() {
         if (IsAddop(Look)) {
             EmitLn("CLR D0");  //unaryAdd ptg???
@@ -364,9 +339,10 @@ public class FormulaParser {
             Term();
         }
         while (IsAddop(Look)) {
-            EmitLn("MOVE D0,-(SP)");
             if ( Look == '+' )  Add();
             if (Look == '-') Subtract();
+            // if (Look == '*') Multiply();
+           // if (Look == '/') Divide();
         }
     }
     
@@ -380,71 +356,104 @@ begin
    Name := GetName;
    Match('=');
    Expression;
-   EmitLn('LEA ' + Name + '(PC),A0');
+
-   EmitLn('MOVE D0,(A0)')
 end;
      **/
     
-    //{--------------------------------------------------------------}
+ 
-    //{ Initialize }
+    /** Initialize */
     
     private void  Init() {
         GetChar();
         SkipWhite();
     }
     
+    /** API call to execute the parsing of the formula
+     *
+     */
     public void parse() {
-        Init();
+        synchronized (tokens) {
-        Expression();
+            Init();
-        //now tokenisation is done .. convert to RPN!!
+            Expression();
-        tokenToRPN();
+        }
     }
     
-    private void tokenToRPN() {
+    /** API call to retrive the array of Ptgs created as 
-        OperationPtg op;
+     * a result of the parsing
-        Ptg operand;
+     */
-        int numOper = 0;
+    public Ptg[] getRPNPtg() {
-        int numOnStack = 0;
+       synchronized (tokens) {
-        result.add(operandsList.pop()); numOnStack++;
+            if (tokens == null) throw new IllegalStateException("Please parse a string before trying to access the parse result");
+            Ptg[] retval = new Ptg[tokens.size()];
+            return (Ptg[]) tokens.toArray(retval);
+       }
+    }
     
-        while (!operationsList.isEmpty()) {
+    /** Static method to convert an array of Ptgs in RPN order 
-            op = (OperationPtg) operationsList.pop();
+     *  to a human readable string format in infix mode
-            if (op instanceof ParenthesisPtg) {
+     *  TODO - extra brackets might appear, but string will be semantically correct. 
-                // do something smart
+     */
-            }
+    public static String toFormulaString(Ptg[] ptgs) {
+        java.util.Stack stack = new java.util.Stack();
+        int numPtgs = ptgs.length;
+        OperationPtg o;
+        int numOperands;
+        String[] operands;
+        for (int i=0;i<numPtgs;i++) {
+            if (ptgs[i] instanceof OperationPtg) {
+                o = (OperationPtg) ptgs[i];
+                numOperands = o.getNumberOfOperands();
+                operands = new String[numOperands];
+                for (int j=0;j<numOperands;j++) {
+                    operands[numOperands-j-1] = (String) stack.pop(); //TODO: catch stack underflow and throw parse exception. 
                     
-            
-            for (numOper = op.getNumberOfOperands();numOper>0;numOper--) {
-                if (numOnStack==0) {
-                    result.add(operandsList.pop());//numOnStack++;
-                } else {
-                    numOnStack--;
                 }  
+                String result = o.toFormulaString(operands);
+                //if (! (o instanceof DummyFunctionPtg) ) result = "("+result+")" ;
+                stack.push(result);
+            } else {
+                stack.push(ptgs[i].toFormulaString());
             }
-            result.add(op);
-            numOnStack++;
         }
+        return (String) stack.pop(); //TODO: catch stack underflow and throw parse exception. 
     }
    
     public String toString() {
         StringBuffer buf = new StringBuffer();
-           for (int i=0;i<result.size();i++) {
+           for (int i=0;i<tokens.size();i++) {
-            buf.append( ( (Ptg)result.get(i)).toFormulaString());
+            buf.append( ( (Ptg)tokens.get(i)).toFormulaString());
             buf.append(' ');
         } 
         return buf.toString();
     }
     
     
-    //{--------------------------------------------------------------}
+    /** Main Program for testing*/
-    //{ Main Program for testing}
     public static void main(String[] argv) {
         FormulaParser fp = new FormulaParser(argv[0]+";");
+        System.out.println("\nFormula is: ");
         fp.parse();
-        System.out.println(fp.toString());
+        System.out.println("RPN Form is: " +fp.toString());
         
+        System.out.println("Converted Text form is : "+fp.toFormulaString(fp.getRPNPtg()));
+        try {
+        short            rownum = 0;
+        FileOutputStream out    = new FileOutputStream("test.xls");
+        HSSFWorkbook     wb     = new HSSFWorkbook();
+        HSSFSheet        s      = wb.createSheet();
+        HSSFRow          r      = null;
+        HSSFCell         c      = null;
+        
+        r = s.createRow((short) 0);
+        c = r.createCell((short) 0);
+        c.setCellFormula(argv[0]);
+        
+        wb.write(out);
+        out.close();
+        } catch (java.io.IOException ioe) {
+            ioe.printStackTrace();
+        }
         //If Look <> CR then Expected('NewLine');
     }
-    //{--------------------------------------------------------------}
     
 } 

src/java/org/apache/poi/hssf/record/formula/MultiplyPtg.java

@@ -132,6 +132,16 @@ public class MultiplyPtg
         return buffer.toString();
     }
     
+    public String toFormulaString(String[] operands) {
+        StringBuffer buffer = new StringBuffer();
+
+        buffer.append(operands[ 0 ]);
+        buffer.append("*");
+        buffer.append(operands[ 1 ]);
+        return buffer.toString();
+    }
+    
+    
     public void manipulate(List source, List results, int pos) {
         standardBinaryManipulation(source, results, pos);
     }
@@ -155,4 +165,5 @@ public class MultiplyPtg
     }
     
     
+
 }

src/java/org/apache/poi/hssf/record/formula/OperationPtg.java

@@ -75,6 +75,10 @@ public abstract class OperationPtg extends Ptg
 
     public abstract int getType();
     
+    public abstract String toFormulaString(String[] operands);
+    
+    public abstract int getPrecedence();
+
     public abstract int getNumberOfOperands();
     
     /**

src/java/org/apache/poi/hssf/record/formula/ParenthesisPtg.java

@@ -58,9 +58,9 @@ package org.apache.poi.hssf.record.formula;
 import java.util.List;
 
 /**
- * Dummy class, we want it only for for the parsing process
+ * While formula tokens are stored in RPN order and thus do not need parenthesis for 
- * does not actually get into the file  -- note by andy...there is a parenthesis PTG
+ * precedence reasons, Parenthesis tokens ARE written to ensure that user entered
- * that can be written and is sometimes!
+ * parenthesis are displayed as-is on reading back
  *
  * Avik Sengupta <lists@aviksengupta.com>
  * Andrew C. Oliver (acoliver at apache dot org)
@@ -69,17 +69,18 @@ public class ParenthesisPtg
     extends OperationPtg
 {
    
-
+    private final static int SIZE = 1;
+    public final static byte sid  = 0x15;
    
 
     public void writeBytes(byte [] array, int offset)
     {
-        //do nothing
+        array[ offset + 0 ] = sid;
     }
 
     public int getSize()
     {
-        return 0;
+        return SIZE;
     }
 
     public int getType()
@@ -89,21 +90,29 @@ public class ParenthesisPtg
 
     public int getNumberOfOperands()
     {
-        return 0;
+        return 1;
     }
 
     public String toFormulaString()
     {
-        return "(";
+        return "()";
     }
 
     public String toFormulaString(Ptg [] operands)
     {
-        return "(";
+        return "";
     }
     
     public void manipulate(List source, List results, int pos) {
     }
     
+    public String toFormulaString(String[] operands) {
+        return "("+operands[0]+")";
+    }    
+    
+    public int getPrecedence() {
+        return 2;
+    }    
+    
 }
 

src/java/org/apache/poi/hssf/record/formula/PowerPtg.java

@@ -110,6 +110,10 @@ public class PowerPtg
         return "^";
     }
     
+    public int getPrecedence() {
+        return 3;
+    }
+
     public String toFormulaString(Ptg [] operands)
     {
         StringBuffer buffer = new StringBuffer();
@@ -120,7 +124,20 @@ public class PowerPtg
         return buffer.toString();
     }
         
+    
+    public String toFormulaString(String[] operands) {
+         StringBuffer buffer = new StringBuffer();
+
+        buffer.append(operands[ 1 ]);
+        buffer.append("^");
+        buffer.append(operands[ 0 ]);
+        return buffer.toString();
+    }
+    
+
+    
     public void manipulate(List source, List results, int pos) {
     }
     
+
 }

src/java/org/apache/poi/hssf/record/formula/Ptg.java

@@ -77,6 +77,54 @@ public abstract class Ptg
     {
     }
     
+    /** convert infix order ptg list to rpn order ptg list
+     * @return List ptgs in RPN order
+     * @param infixPtgs List of ptgs in infix order
+     */
+    public static List ptgsToRpn(List infixPtgs) {
+        java.util.Stack operands = new java.util.Stack();
+        java.util.List retval = new java.util.Stack();
+        
+        java.util.ListIterator i = infixPtgs.listIterator();
+        Object p;
+        OperationPtg o ;
+        boolean weHaveABracket = false;
+        while (i.hasNext()) {
+            p=i.next();
+            if (p instanceof OperationPtg) {
+                if (p instanceof ParenthesisPtg) {
+                    if (!weHaveABracket) {
+                        operands.push(p);
+                        weHaveABracket = true;
+                    } else {
+                        o = (OperationPtg) operands.pop();
+                        while (!(o instanceof ParenthesisPtg)) { 
+                            retval.add(o);
+                        }
+                        weHaveABracket = false;
+                    }
+                } else {
+                    
+                    while  (!operands.isEmpty() && ((OperationPtg) operands.peek()).getPrecedence() >= ((OperationPtg) p).getPrecedence() ) { //TODO handle ^ since it is right associative
+                        retval.add(operands.pop());
+                    }
+                    operands.push(p);
+                }
+            } else {
+                retval.add(p);
+            }
+        }
+        while (!operands.isEmpty()) {
+            if (operands.peek() instanceof ParenthesisPtg ){
+                //throw some error
+            } else {
+                retval.add(operands.pop());
+            }   
+        }
+        return retval;
+    }
+    
+
     
     
     /*

src/java/org/apache/poi/hssf/record/formula/SubtractPtg.java

@@ -120,6 +120,24 @@ public class SubtractPtg
         return buffer.toString();
     }
 
+     public int getPrecedence() {
+        return 5;
+    }
+    
+    public int getStringLength() {
+        return 1;
+    }
+    
+    public String toFormulaString(String[] operands) {
+        StringBuffer buffer = new StringBuffer();
+
+        buffer.append(operands[ 0 ]);
+        buffer.append("-");
+        buffer.append(operands[ 1 ]);
+        return buffer.toString();
+    }
+    
+   
     public void manipulate(List source, List results, int pos) {
     }
     

src/java/org/apache/poi/hssf/record/formula/ValueVariableFunctionPtg.java

@@ -129,7 +129,19 @@ public class ValueVariableFunctionPtg
         return toFormulaString();
     }
 
+    
+    public String toFormulaString(String[] operands) {
+        return toFormulaString();
+    }
+    
+   
     public void manipulate(List source, List results, int pos) {
     }
     
+    public int getPrecedence() {
+        return 1;
+    }    
+    
+    
+
 }

src/java/org/apache/poi/hssf/usermodel/HSSFCell.java

@@ -70,6 +70,9 @@ import org.apache.poi.hssf.record.NumberRecord;
 import org.apache.poi.hssf.record.BlankRecord;
 import org.apache.poi.hssf.record.BoolErrRecord;
 import org.apache.poi.hssf.record.ExtendedFormatRecord;
+import org.apache.poi.hssf.record.formula.Ptg;
+
+import org.apache.poi.hssf.record.formula.FormulaParser;
 
 import java.util.Date;
 import java.util.Calendar;
@@ -684,6 +687,32 @@ public class HSSFCell
         }
     }
 
+    public void setCellFormula(String formula) {
+        if (formula==null) {
+            setCellType(CELL_TYPE_BLANK,false);
+        } else {
+            
+            setCellType(CELL_TYPE_FORMULA,false);
+            FormulaRecord rec = (FormulaRecord) record;
+            rec.setOptions(( short ) 2);
+            rec.setValue(0);
+            rec.setXFIndex(( short ) 0x0f);
+            FormulaParser fp = new FormulaParser(formula+";");
+            fp.parse();
+            Ptg[] ptg  = fp.getRPNPtg();
+            int   size = 0;
+            System.out.println("got Ptgs " + ptg.length);
+            for (int k = 0; k < ptg.length; k++) {
+                size += ptg[ k ].getSize();
+                rec.pushExpressionToken(ptg[ k ]);
+            }
+            rec.setExpressionLength(( short ) size);
+            //return rec;
+            
+        }
+    }
+    
+    
     /**
      * get the value of the cell as a number.  For strings we throw an exception.
      * For blank cells we return a 0.