/**
         * Parses the sublist of tokens.  In most cases this will equate to
         * the full list
         *
         * @param len the length of the subexpression to parse
         * @exception FormulaException
         */
        private void parseSubExpression(int len)
        {
            int tokenVal = 0;
            Token t = null;

            // Indicates that we are parsing the incredibly complicated and
            // hacky if construct that MS saw fit to include, the gits
            Stack<ParseItem> ifStack = new Stack<ParseItem>();

            // The end position of the sub-expression
            int endpos = pos + len;

            while (pos < endpos)
                {
                tokenVal = tokenData[pos];
                pos++;

                t = Token.getToken(tokenVal);

                if (t == Token.UNKNOWN)
                    {
                    throw new FormulaException
                      (FormulaException.UNRECOGNIZED_TOKEN,tokenVal);
                    }

                Assert.verify(t != Token.UNKNOWN);

                // Operands
                if (t == Token.REF)
                    {
                    CellReference cr = new CellReference(relativeTo);
                    pos += cr.read(tokenData,pos);
                    tokenStack.Push(cr);
                    }
                else if (t == Token.REFERR)
                    {
                    CellReferenceError cr = new CellReferenceError();
                    pos += cr.read(tokenData,pos);
                    tokenStack.Push(cr);
                    }
                else if (t == Token.ERR)
                    {
                    ErrorConstant ec = new ErrorConstant();
                    pos += ec.read(tokenData,pos);
                    tokenStack.Push(ec);
                    }
                else if (t == Token.REFV)
                    {
                    SharedFormulaCellReference cr =
                      new SharedFormulaCellReference(relativeTo);
                    pos += cr.read(tokenData,pos);
                    tokenStack.Push(cr);
                    }
                else if (t == Token.REF3D)
                    {
                    CellReference3d cr = new CellReference3d(relativeTo,workbook);
                    pos += cr.read(tokenData,pos);
                    tokenStack.Push(cr);
                    }
                else if (t == Token.AREA)
                    {
                    Area a = new Area();
                    pos += a.read(tokenData,pos);
                    tokenStack.Push(a);
                    }
                else if (t == Token.AREAV)
                    {
                    SharedFormulaArea a = new SharedFormulaArea(relativeTo);
                    pos += a.read(tokenData,pos);
                    tokenStack.Push(a);
                    }
                else if (t == Token.AREA3D)
                    {
                    Area3d a = new Area3d(workbook);
                    pos += a.read(tokenData,pos);
                    tokenStack.Push(a);
                    }
                else if (t == Token.NAME)
                    {
                    Name n = new Name();
                    pos += n.read(tokenData,pos);
                    n.setParseContext(parseContext);
                    tokenStack.Push(n);
                    }
                else if (t == Token.NAMED_RANGE)
                    {
                    NameRange nr = new NameRange(nameTable);
                    pos += nr.read(tokenData,pos);
                    nr.setParseContext(parseContext);
                    tokenStack.Push(nr);
                    }
                else if (t == Token.INTEGER)
                    {
                    IntegerValue i = new IntegerValue();
                    pos += i.read(tokenData,pos);
                    tokenStack.Push(i);
                    }
                else if (t == Token.DOUBLE)
                    {
                    DoubleValue d = new DoubleValue();
                    pos += d.read(tokenData,pos);
                    tokenStack.Push(d);
                    }
                else if (t == Token.BOOL)
                    {
                    BooleanValue bv = new BooleanValue();
                    pos += bv.read(tokenData,pos);
                    tokenStack.Push(bv);
                    }
                else if (t == Token.STRING)
                    {
                    StringValue sv = new StringValue(settings);
                    pos += sv.read(tokenData,pos);
                    tokenStack.Push(sv);
                    }
                else if (t == Token.MISSING_ARG)
                    {
                    MissingArg ma = new MissingArg();
                    pos += ma.read(tokenData,pos);
                    tokenStack.Push(ma);
                    }

                  // Unary Operators
                else if (t == Token.UNARY_PLUS)
                    {
                    UnaryPlus up = new UnaryPlus();
                    pos += up.read(tokenData,pos);
                    addOperator(up);
                    }
                else if (t == Token.UNARY_MINUS)
                    {
                    UnaryMinus um = new UnaryMinus();
                    pos += um.read(tokenData,pos);
                    addOperator(um);
                    }
                else if (t == Token.PERCENT)
                    {
                    Percent p = new Percent();
                    pos += p.read(tokenData,pos);
                    addOperator(p);
                    }

                  // Binary Operators
                else if (t == Token.SUBTRACT)
                    {
                    Subtract s = new Subtract();
                    pos += s.read(tokenData,pos);
                    addOperator(s);
                    }
                else if (t == Token.ADD)
                    {
                    Add s = new Add();
                    pos += s.read(tokenData,pos);
                    addOperator(s);
                    }
                else if (t == Token.MULTIPLY)
                    {
                    Multiply s = new Multiply();
                    pos += s.read(tokenData,pos);
                    addOperator(s);
                    }
                else if (t == Token.DIVIDE)
                    {
                    Divide s = new Divide();
                    pos += s.read(tokenData,pos);
                    addOperator(s);
                    }
                else if (t == Token.CONCAT)
                    {
                    Concatenate c = new Concatenate();
                    pos += c.read(tokenData,pos);
                    addOperator(c);
                    }
                else if (t == Token.POWER)
                    {
                    Power p = new Power();
                    pos += p.read(tokenData,pos);
                    addOperator(p);
                    }
                else if (t == Token.LESS_THAN)
                    {
                    LessThan lt = new LessThan();
                    pos += lt.read(tokenData,pos);
                    addOperator(lt);
                    }
                else if (t == Token.LESS_EQUAL)
                    {
                    LessEqual lte = new LessEqual();
                    pos += lte.read(tokenData,pos);
                    addOperator(lte);
                    }
                else if (t == Token.GREATER_THAN)
                    {
                    GreaterThan gt = new GreaterThan();
                    pos += gt.read(tokenData,pos);
                    addOperator(gt);
                    }
                else if (t == Token.GREATER_EQUAL)
                    {
                    GreaterEqual gte = new GreaterEqual();
                    pos += gte.read(tokenData,pos);
                    addOperator(gte);
                    }
                else if (t == Token.NOT_EQUAL)
                    {
                    NotEqual ne = new NotEqual();
                    pos += ne.read(tokenData,pos);
                    addOperator(ne);
                    }
                else if (t == Token.EQUAL)
                    {
                    Equal e = new Equal();
                    pos += e.read(tokenData,pos);
                    addOperator(e);
                    }
                else if (t == Token.PARENTHESIS)
                    {
                    Parenthesis p = new Parenthesis();
                    pos += p.read(tokenData,pos);
                    addOperator(p);
                    }

                  // Functions
                else if (t == Token.ATTRIBUTE)
                    {
                    Attribute a = new Attribute(settings);
                    pos += a.read(tokenData,pos);

                    if (a.isSum())
                        addOperator(a);
                    else if (a.isIf())
                        {
                        // Add it to a special stack for ifs
                        ifStack.Push(a);
                        }
                    }
                else if (t == Token.FUNCTION)
                    {
                    BuiltInFunction bif = new BuiltInFunction(settings);
                    pos += bif.read(tokenData,pos);

                    addOperator(bif);
                    }
                else if (t == Token.FUNCTIONVARARG)
                    {
                    VariableArgFunction vaf = new VariableArgFunction(settings);
                    pos += vaf.read(tokenData,pos);

                    if (vaf.getFunction() != Function.ATTRIBUTE)
                        addOperator(vaf);
                    else
                        {
                        // This is part of an IF function.  Get the operands, but then
                        // add it to the top of the if stack
                        vaf.getOperands(tokenStack);

                        Attribute ifattr = null;
                        if (ifStack.Count == 0)
                            ifattr = new Attribute(settings);
                        else
                            ifattr = (Attribute)ifStack.Pop();

                        ifattr.setIfConditions(vaf);
                        tokenStack.Push(ifattr);
                        }
                    }

                    // Other things
                else if (t == Token.MEM_FUNC)
                    {
                    MemFunc memFunc = new MemFunc();
                    handleMemoryFunction(memFunc);
                    }
                else if (t == Token.MEM_AREA)
                    {
                    MemArea memArea = new MemArea();
                    handleMemoryFunction(memArea);
                    }
                }
        }
예제 #2
0
        /**
         * Parses the sublist of tokens.  In most cases this will equate to
         * the full list
         *
         * @param len the length of the subexpression to parse
         * @exception FormulaException
         */
        private void parseSubExpression(int len)
        {
            int   tokenVal = 0;
            Token t        = null;

            // Indicates that we are parsing the incredibly complicated and
            // hacky if construct that MS saw fit to include, the gits
            Stack <ParseItem> ifStack = new Stack <ParseItem>();

            // The end position of the sub-expression
            int endpos = pos + len;

            while (pos < endpos)
            {
                tokenVal = tokenData[pos];
                pos++;

                t = Token.getToken(tokenVal);

                if (t == Token.UNKNOWN)
                {
                    throw new FormulaException
                              (FormulaException.UNRECOGNIZED_TOKEN, tokenVal);
                }

                Assert.verify(t != Token.UNKNOWN);

                // Operands
                if (t == Token.REF)
                {
                    CellReference cr = new CellReference(relativeTo);
                    pos += cr.read(tokenData, pos);
                    tokenStack.Push(cr);
                }
                else if (t == Token.REFERR)
                {
                    CellReferenceError cr = new CellReferenceError();
                    pos += cr.read(tokenData, pos);
                    tokenStack.Push(cr);
                }
                else if (t == Token.ERR)
                {
                    ErrorConstant ec = new ErrorConstant();
                    pos += ec.read(tokenData, pos);
                    tokenStack.Push(ec);
                }
                else if (t == Token.REFV)
                {
                    SharedFormulaCellReference cr =
                        new SharedFormulaCellReference(relativeTo);
                    pos += cr.read(tokenData, pos);
                    tokenStack.Push(cr);
                }
                else if (t == Token.REF3D)
                {
                    CellReference3d cr = new CellReference3d(relativeTo, workbook);
                    pos += cr.read(tokenData, pos);
                    tokenStack.Push(cr);
                }
                else if (t == Token.AREA)
                {
                    Area a = new Area();
                    pos += a.read(tokenData, pos);
                    tokenStack.Push(a);
                }
                else if (t == Token.AREAV)
                {
                    SharedFormulaArea a = new SharedFormulaArea(relativeTo);
                    pos += a.read(tokenData, pos);
                    tokenStack.Push(a);
                }
                else if (t == Token.AREA3D)
                {
                    Area3d a = new Area3d(workbook);
                    pos += a.read(tokenData, pos);
                    tokenStack.Push(a);
                }
                else if (t == Token.NAME)
                {
                    Name n = new Name();
                    pos += n.read(tokenData, pos);
                    n.setParseContext(parseContext);
                    tokenStack.Push(n);
                }
                else if (t == Token.NAMED_RANGE)
                {
                    NameRange nr = new NameRange(nameTable);
                    pos += nr.read(tokenData, pos);
                    nr.setParseContext(parseContext);
                    tokenStack.Push(nr);
                }
                else if (t == Token.INTEGER)
                {
                    IntegerValue i = new IntegerValue();
                    pos += i.read(tokenData, pos);
                    tokenStack.Push(i);
                }
                else if (t == Token.DOUBLE)
                {
                    DoubleValue d = new DoubleValue();
                    pos += d.read(tokenData, pos);
                    tokenStack.Push(d);
                }
                else if (t == Token.BOOL)
                {
                    BooleanValue bv = new BooleanValue();
                    pos += bv.read(tokenData, pos);
                    tokenStack.Push(bv);
                }
                else if (t == Token.STRING)
                {
                    StringValue sv = new StringValue(settings);
                    pos += sv.read(tokenData, pos);
                    tokenStack.Push(sv);
                }
                else if (t == Token.MISSING_ARG)
                {
                    MissingArg ma = new MissingArg();
                    pos += ma.read(tokenData, pos);
                    tokenStack.Push(ma);
                }

                // Unary Operators
                else if (t == Token.UNARY_PLUS)
                {
                    UnaryPlus up = new UnaryPlus();
                    pos += up.read(tokenData, pos);
                    addOperator(up);
                }
                else if (t == Token.UNARY_MINUS)
                {
                    UnaryMinus um = new UnaryMinus();
                    pos += um.read(tokenData, pos);
                    addOperator(um);
                }
                else if (t == Token.PERCENT)
                {
                    Percent p = new Percent();
                    pos += p.read(tokenData, pos);
                    addOperator(p);
                }

                // Binary Operators
                else if (t == Token.SUBTRACT)
                {
                    Subtract s = new Subtract();
                    pos += s.read(tokenData, pos);
                    addOperator(s);
                }
                else if (t == Token.ADD)
                {
                    Add s = new Add();
                    pos += s.read(tokenData, pos);
                    addOperator(s);
                }
                else if (t == Token.MULTIPLY)
                {
                    Multiply s = new Multiply();
                    pos += s.read(tokenData, pos);
                    addOperator(s);
                }
                else if (t == Token.DIVIDE)
                {
                    Divide s = new Divide();
                    pos += s.read(tokenData, pos);
                    addOperator(s);
                }
                else if (t == Token.CONCAT)
                {
                    Concatenate c = new Concatenate();
                    pos += c.read(tokenData, pos);
                    addOperator(c);
                }
                else if (t == Token.POWER)
                {
                    Power p = new Power();
                    pos += p.read(tokenData, pos);
                    addOperator(p);
                }
                else if (t == Token.LESS_THAN)
                {
                    LessThan lt = new LessThan();
                    pos += lt.read(tokenData, pos);
                    addOperator(lt);
                }
                else if (t == Token.LESS_EQUAL)
                {
                    LessEqual lte = new LessEqual();
                    pos += lte.read(tokenData, pos);
                    addOperator(lte);
                }
                else if (t == Token.GREATER_THAN)
                {
                    GreaterThan gt = new GreaterThan();
                    pos += gt.read(tokenData, pos);
                    addOperator(gt);
                }
                else if (t == Token.GREATER_EQUAL)
                {
                    GreaterEqual gte = new GreaterEqual();
                    pos += gte.read(tokenData, pos);
                    addOperator(gte);
                }
                else if (t == Token.NOT_EQUAL)
                {
                    NotEqual ne = new NotEqual();
                    pos += ne.read(tokenData, pos);
                    addOperator(ne);
                }
                else if (t == Token.EQUAL)
                {
                    Equal e = new Equal();
                    pos += e.read(tokenData, pos);
                    addOperator(e);
                }
                else if (t == Token.PARENTHESIS)
                {
                    Parenthesis p = new Parenthesis();
                    pos += p.read(tokenData, pos);
                    addOperator(p);
                }

                // Functions
                else if (t == Token.ATTRIBUTE)
                {
                    Attribute a = new Attribute(settings);
                    pos += a.read(tokenData, pos);

                    if (a.isSum())
                    {
                        addOperator(a);
                    }
                    else if (a.isIf())
                    {
                        // Add it to a special stack for ifs
                        ifStack.Push(a);
                    }
                }
                else if (t == Token.FUNCTION)
                {
                    BuiltInFunction bif = new BuiltInFunction(settings);
                    pos += bif.read(tokenData, pos);

                    addOperator(bif);
                }
                else if (t == Token.FUNCTIONVARARG)
                {
                    VariableArgFunction vaf = new VariableArgFunction(settings);
                    pos += vaf.read(tokenData, pos);

                    if (vaf.getFunction() != Function.ATTRIBUTE)
                    {
                        addOperator(vaf);
                    }
                    else
                    {
                        // This is part of an IF function.  Get the operands, but then
                        // add it to the top of the if stack
                        vaf.getOperands(tokenStack);

                        Attribute ifattr = null;
                        if (ifStack.Count == 0)
                        {
                            ifattr = new Attribute(settings);
                        }
                        else
                        {
                            ifattr = (Attribute)ifStack.Pop();
                        }

                        ifattr.setIfConditions(vaf);
                        tokenStack.Push(ifattr);
                    }
                }

                // Other things
                else if (t == Token.MEM_FUNC)
                {
                    MemFunc memFunc = new MemFunc();
                    handleMemoryFunction(memFunc);
                }
                else if (t == Token.MEM_AREA)
                {
                    MemArea memArea = new MemArea();
                    handleMemoryFunction(memArea);
                }
            }
        }