lyfz_repos/铂金版源码/Biff8/Formulas/Formula.cs

using System;
using System.Collections.Generic;
using System.Text;
using Biff8Excel.Interfaces;
using System.Runtime.InteropServices;
using Biff8Excel.Excel;

namespace Biff8Excel.Formulas
{
    [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 1)]
    struct sFormula 
    {
        public ushort opcode;
        public ushort length;
        public ushort row;
        public ushort col;
        public ushort xf;
        public double resul;
        public ushort flags;
        public uint notused;
    }

    public class Formula : IRecords 
    {
        string m_Formula = "";
        IExternSheet m_externSheet;
        ushort m_thisSheetNumber;
        const int formulaLength = 24;
        sFormula formula;

        public Formula()
        {
            formula.opcode = 0x6;
            formula.notused = 0x0;
            //formula.flags = 0x1;
        }

        private byte[] SerializableTokens()
        {
            ReversePolishNotation rpn;
            List<string> tokens;
            Referencer reference;
            string token;
            byte[] b = new byte[1024 * 8];      // create a buffer   8k
            byte[] btmp;
            ushort offset = 2;                   // leave roon for the length
            string name;
            int id;
            double db;

            // parse the supplied formula
            tokens = Globals.ParseFormula(m_Formula);

            // Convert the tokens to reverse polish notation
            rpn = new ReversePolishNotation();
            tokens = rpn.ConverToReversePolishNotation(tokens);

            for (int i = 0; i < tokens.Count; i++)
            {
                token = tokens[i];
                // NUMERIC VALUE, Is it a integer or float
                if (double.TryParse(token, out db))
                {
                    if (token.IndexOf(".") > -1)           // Integer or float
                    {
                        b[offset] = Globals.tokenINT;
                        offset += 1;                            // integer identifier
                        BitConverter.GetBytes(ushort.Parse(token)).CopyTo(b, offset);
                        offset += 2;                            // Value
                    }
                    else
                    {
                        b[offset] = Globals.tokenNUM;
                        offset += 1;                                // float indentifier
                        BitConverter.GetBytes(db).CopyTo(b, offset);
                        offset += 8;                                // Value
                    }
                }
                // FUNCTION VALUE,
                else if (Globals.g_sSupported.IndexOf(Globals.GetFunctionName(token)) > -1)
                {
                    name = Globals.GetFunctionName(tokens[i]);
                    switch (name)
                    {
                        case "SUM": id = Globals.IDENTIFIER_SUM; break;
                        case "AVERAGE": id = Globals.IDENTIFIER_AVERAGE; break;
                        case "COUNT": id = Globals.IDENTIFIER_COUNT; break;
                        default:
                                id = Globals.IDENTIFIER_AVERAGE ;
                                break;
                    }
                    reference = new Referencer();
                    reference.ExternSheet = m_externSheet;
                    btmp = reference.Serialize(token);
                    reference = null;

                    //btmp = TArray<byte>.Preserve(btmp, (int)(btmp.Length + 4));
                    Array.Resize<byte>(ref btmp, btmp.Length + 4);
                    BitConverter.GetBytes(id).CopyTo(btmp, btmp.Length - 4);
                    btmp.CopyTo(b, offset);
                    offset += (ushort)(btmp.Length);
                }
                // CELL REFERENCE
                else if (token.Length > 1)
                {
                    reference = new Referencer();
                    reference.ExternSheet = m_externSheet;
                    btmp = reference.Serialize(token);
                    reference = null;

                    // add the sum identifier to the end of array
                    btmp.CopyTo(b, offset);
                    offset += (ushort)(btmp.Length);
                }
                //OPERATOR
                else 
                {
                    switch (token)
                    {
                        case "+": b[offset] = Globals.tokenADD; offset++; break;
                        case "-": b[offset] = Globals.tokenSUBTRACT; offset++; break;
                        case "*": b[offset] = Globals.tokenMULTIPLY; offset++; break;
                        case "/": b[offset] = Globals.tokenDIVIDE; offset++; break;
                        case "^": b[offset] = Globals.tokenPOWER; offset++; break;
                        default:
                            break;
                    }
                }
            }  // end for

            byte[] tmp = new byte[offset];
            Array.Copy(b, tmp, offset);
            offset = (ushort)(tmp.Length - 2);

            // save the tokens length
            BitConverter.GetBytes(offset).CopyTo(tmp,0);

            return tmp;
        }

        public double CalculateCell(ExcelCellDictionary sheetCells)
        //public double CalculateCell(ExcelCellLink sheetCells)
        {
            ReversePolishNotation rpn = new ReversePolishNotation();
            Calculator oCalc = new Calculator();
            List<string> tokens = new List<string>();

            // parset the supplied formula
            tokens = Globals.ParseFormula(m_Formula);

            // Convert the tokens to reverse polis notation
            tokens = rpn.ConverToReversePolishNotation(tokens);


            //  calculate the formula expression and return the result
            //  returns empty if the formula could not be resloved
            oCalc.CellCollection = sheetCells;
            oCalc.ExternSheet = m_externSheet;

            oCalc.ThisSheetNumber = m_thisSheetNumber;
            return oCalc.Calculate(tokens);
        }

        // If there are no sheets in the function string, use
        // this value to make sure we only reference cells from the formulas sheet
        public ushort ThisSheetNumber
        {
            set { m_thisSheetNumber = value; }
        }

        public string[] SheetNames
        {
            set { Globals.g_arrSheetNames = value; }
        }

        public string FormulaString
        {
            set { m_Formula = value; }
        }

        public ushort Row
        {
            set { formula.row = value; }
        }

        public ushort Column
        {
            set { formula.col = value; }
        }

        public ushort CellStyle
        {
            set { formula.xf = value; }                                                                       
        }

        public double Result
        {
            set { formula.resul = value; }
        }

        public ushort Flags
        {
            set { formula.flags = value; }
        }

        public IExternSheet ExternSheet
        {
            set { m_externSheet = value; }
        }


        #region IRecords ³ÉÔ±

        public byte[] GetByte()
        {
            byte[] tmp = SerializableTokens();
            formula.length = (ushort)(tmp.Length + formulaLength - 4);

            byte[] result = new byte[tmp.Length + formulaLength];

            Globals.GetStructToBytes(formula).CopyTo(result, 0);
            tmp.CopyTo(result, 24);

            return result;
        }

        #endregion
    }
}