using System;
using System.Collections.Generic;
using System.Text;

namespace Mesnac.Basic
{
    class Analyzer
    {
    }
    /// <summary>
    /// 运算符类型(从上到下优先级依次递减)
    /// </summary>
    public enum OperatorType
    {
        /// <summary>
        /// 左括号:(,left bracket
        /// </summary>
        LB = 10,

        /// <summary>
        /// 右括号),right bracket
        /// </summary>
        RB = 11,

        /// <summary>
        /// 逻辑非,!,NOT
        /// </summary>
        NOT = 20,

        /// <summary>
        /// 正号,+,positive sign
        /// </summary>
        PS = 21,

        /// <summary>
        /// 负号,-,negative sign
        /// </summary>
        NS = 22,

        /// <summary>
        /// 乘,*,multiplication
        /// </summary>
        MUL = 30,

        /// <summary>
        /// 除,/,division
        /// </summary>
        DIV = 31,

        /// <summary>
        /// 余,%,modulus
        /// </summary>
        MOD = 32,

        /// <summary>
        /// 加,+,Addition
        /// </summary>
        ADD = 40,

        /// <summary>
        /// 减,-,subtraction
        /// </summary>
        SUB = 41,

        /// <summary>
        /// 小于,less than
        /// </summary>
        LT = 50,

        /// <summary>
        /// 小于或等于,less than or equal to
        /// </summary>
        LE = 51,

        /// <summary>
        /// 大于,>,greater than
        /// </summary>
        GT = 52,

        /// <summary>
        /// 大于或等于,>=,greater than or equal to
        /// </summary>
        GE = 53,

        /// <summary>
        /// 等于,=,equal to
        /// </summary>
        ET = 60,

        /// <summary>
        /// 不等于,unequal to
        /// </summary>
        UT = 61,

        /// <summary>
        /// 逻辑与,&,AND
        /// </summary>
        AND = 70,

        /// <summary>
        /// 逻辑或,|,OR
        /// </summary>
        OR = 71,

        /// <summary>
        /// 逗号,comma
        /// </summary>
        CA = 80,

        /// <summary>
        /// 结束符号
        /// </summary>
        END = 255,

        /// <summary>
        /// 错误符号
        /// </summary>
        ERR = 256

    }

    /// <summary>
    /// 运算符
    /// </summary>
    public class Operator
    {
        private OperatorType type = OperatorType.END;
        private string value = "";

        public Operator(OperatorType type, string value)
        {
            this.type = type;
            this.value = value;
        }

        /// <summary>
        /// 运算符类型
        /// </summary>
        public OperatorType Type
        {
            get
            {
                return this.type;
            }
            set
            {
                this.type = value;
            }
        }

        /// <summary>
        /// 运算符值
        /// </summary>
        public string Value
        {
            get
            {
                return this.value;
            }
            set
            {
                this.value = value;
            }
        }

    }





    /// <summary>
    /// 操作数类型
    /// </summary>
    public enum OperandType
    {
        /// <summary>
        /// 函数
        /// </summary>
        FUNC = 1,

        /// <summary>
        /// 日期
        /// </summary>
        DATE = 2,

        /// <summary>
        /// 数字
        /// </summary>
        NUMBER = 3,

        /// <summary>
        /// 布尔
        /// </summary>
        BOOLEAN = 4,

        /// <summary>
        /// 字符串
        /// </summary>
        STRING = 5

    }

    /// <summary>
    /// 操作数
    /// </summary>
    public class Operand
    {
        private OperandType type = OperandType.STRING;
        private string key = "";
        private object value = null;

        public Operand(OperandType type, object value)
        {
            this.type = type;
            this.value = value;
        }

        /// <summary>
        /// 操作数类型
        /// </summary>
        public OperandType Type
        {
            get
            {
                return this.type;
            }
            set
            {
                this.type = value;
            }
        }

        /// <summary>
        /// 关键字
        /// </summary>
        public string Key
        {
            get
            {
                return this.key;
            }
            set
            {
                this.key = value;
            }
        }

        /// <summary>
        /// 操作数值
        /// </summary>
        public object Value
        {
            get
            {
                return this.value;
            }
            set
            {
                this.value = value;
            }
        }
    }
    /// <summary>
    /// 语法分析器
    /// </summary>
    public class AccidenceAnalyzer
    {


        private string m_Operator = "()!*/%+-<>=&|,";    //运算符
        private Stack<object> m_tokens = null;            //语法单元堆栈
        private string m_Message = "";                        //消息



        /// <summary>
        /// 
        /// </summary>
        public AccidenceAnalyzer()
        {
            m_tokens = new Stack<object>();
        }



        /// <summary>
        /// 消息
        /// </summary>
        public string Message
        {
            get
            {
                return m_Message;
            }
        }

        /// <summary>
        /// 返回语法单元集合
        /// </summary>
        public Stack<object> Tokens
        {
            get
            {
                return m_tokens;
            }
        }

        /// <summary>
        /// 包含的运算符
        /// </summary>
        public string Inclusive
        {
            set
            {
                char[] cs = value.ToCharArray();
                foreach (char c in cs)
                {
                    if (m_Operator.IndexOf(c) == -1)
                    {
                        m_Operator += c.ToString();
                    }
                }
            }
        }

        /// <summary>
        /// 排除的运算符
        /// </summary>
        public string Repulsive
        {
            set
            {
                char[] cs = value.ToCharArray();
                int pos = 0;

                foreach (char c in cs)
                {
                    pos = m_Operator.IndexOf(c);
                    if (pos > -1)
                    {
                        m_Operator = m_Operator.Remove(pos, 1);
                    }
                }
            }
        }



        /// <summary>
        /// 语法分析事件
        /// </summary>
        /// <param name="opd">操作数</param>
        /// <returns></returns>
        public delegate bool AccidenceAnalysis(ref Operand opd);
        /// <summary>
        /// 语法分析事件
        /// </summary>
        /// <param name="opd">操作数</param>
        /// <returns></returns>
        public event AccidenceAnalysis OnAccidenceAnalysis;

        /// <summary>
        /// 回调函数
        /// </summary>
        /// <param name="opd">操作数</param>
        /// <param name="msg">错误消息</param>
        public delegate object CallBack(string funcName, object[] param, ref bool isOk);
        /// <summary>
        /// 回调函数
        /// </summary>
        /// <param name="opd">操作数</param>
        /// <param name="msg">错误消息</param>
        public event CallBack OnCallBack;


        /// <summary>
        /// 语法解析,将中缀表达式转换成后缀表达式(即逆波兰表达式)
        /// </summary>
        /// <param name="exp">一个中缀表达式，例如：a+b*c</param>
        /// <returns></returns>
        public bool Parse(string exp)
        {
            /*  将中缀表达式转换成后缀表达式算法：
                1、从左至右扫描一中缀表达式。
                2、若读取的是操作数，则判断该操作数的类型，并将该操作数存入操作数堆栈
                3、若读取的是运算符
                   (1) 该运算符为左括号"("，则直接存入运算符堆栈。
                   (2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到操作数堆栈，直到遇到左括号为止。
                   (3) 该运算符为非括号运算符：
                       (a) 若运算符堆栈栈顶的运算符为括号，则直接存入运算符堆栈。
                       (b) 若比运算符堆栈栈顶的运算符优先级高或相等，则直接存入运算符堆栈。
                       (c) 若比运算符堆栈栈顶的运算符优先级低，则输出栈顶运算符到操作数堆栈，并将当前运算符压入运算符堆栈。
                4、当表达式读取完成后运算符堆栈中尚有运算符时，则依序取出运算符到操作数堆栈，直到运算符堆栈为空。
            */

            m_tokens.Clear();//清空语法单元堆栈
            if (exp.Trim() == "")//表达式不能为空
            {
                return false;
            }
            else if (!this.IsMatching(exp))//括号、引号、单引号等必须配对
            {
                return false;
            }
            else
            {
                Stack<object> tokens = new Stack<object>();             //语法单元堆栈
                Stack<Operator> operators = new Stack<Operator>();      //运算符堆栈
                OperandType operandType = OperandType.STRING;           //操作数类型
                OperatorType operatorType = OperatorType.ERR;           //运算符类型
                string currentOpd = "";                                 //当前操作数
                string currentOpt = "";                                 //当前运算符
                int currentPos = 0;                                     //当前位置
                int funcCount = 0;                                        //函数数量

                exp += "";//加入结束标记
                while (exp != "")
                {
                    currentPos = FindOperator(exp);
                    if (currentPos == -1)
                    {
                        //无运算符,触发语法分析事件
                        Operand opd = new Operand(ConvertOperand(exp), exp);
                        if (this.OnAccidenceAnalysis == null)
                        {
                            tokens.Push(opd);
                        }
                        else
                        {
                            if (OnAccidenceAnalysis(ref opd))
                            {
                                tokens.Push(opd);
                            }
                            else
                            {
                                m_Message = "解析操作数:" + Convert.ToString(opd.Value) + "失败";
                                tokens.Clear();
                                return false;
                            }
                        }
                        break;
                    }
                    else
                    {
                        bool isNS = false;
                        currentOpd = exp.Substring(0, currentPos);
                        if ((currentPos == 0) && (currentOpt != ")") & (exp.Substring(currentPos, 1) == "-"))
                        {
                            isNS = true;
                        }
                        currentOpt = exp.Substring(currentPos, 1);
                        currentOpd = currentOpd.Trim();

                        if (currentOpt == "(")
                        {
                            //函数数量增加
                            if (currentOpd != "")
                            {
                                funcCount++;
                            }
                            //将函数名称存入语法单元堆栈
                            if (currentOpd != "")
                            {
                                tokens.Push(new Operand(ConvertOperand(currentOpd + "("), currentOpd));
                            }
                            //若当前运算符为左括号,则直接存入堆栈。
                            operators.Push(new Operator(OperatorType.LB, "("));
                        }
                        else if (currentOpt == ")")
                        {
                            //分析并存入运算符到语法单元堆栈
                            if (currentOpd != "")
                            {
                                operandType = this.ConvertOperand(currentOpd);
                                if ((operandType != OperandType.STRING) || (funcCount > 0))
                                {
                                    //lizheng add
                                    if (operandType == OperandType.STRING)
                                    {
                                        Operand opd = new Operand(ConvertOperand(currentOpd), currentOpd);
                                        if (this.OnAccidenceAnalysis == null)
                                        {
                                            tokens.Push(opd);
                                        }
                                        else
                                        {
                                            if (OnAccidenceAnalysis(ref opd))
                                            {
                                                tokens.Push(opd);
                                            }
                                            else
                                            {
                                                m_Message = "解析操作数:" + Convert.ToString(opd.Value) + "失败";
                                                tokens.Clear();
                                                return false;
                                            }
                                        }
                                    }
                                    //
                                    else
                                    {
                                        tokens.Push(new Operand(ConvertOperand(currentOpd), currentOpd));
                                    }

                                }
                                else
                                {
                                    Operand opd = new Operand(ConvertOperand(currentOpd), currentOpd);
                                    if (this.OnAccidenceAnalysis == null)
                                    {
                                        tokens.Push(opd);
                                    }
                                    else
                                    {
                                        if (OnAccidenceAnalysis(ref opd))
                                        {
                                            tokens.Push(opd);
                                        }
                                        else
                                        {
                                            m_Message = "解析操作数:" + Convert.ToString(opd.Value) + "失败";
                                            tokens.Clear();
                                            return false;
                                        }
                                    }
                                }
                            }
                            //若当前运算符为右括号,则依次弹出运算符堆栈中的运算符并存入到语法单元堆栈,直到遇到左括号为止.
                            while (operators.Count > 0)
                            {
                                if (operators.Peek().Type != OperatorType.LB)
                                {
                                    tokens.Push(operators.Pop());
                                }
                                else
                                {
                                    tokens.Push(operators.Pop());
                                    tokens.Push(new Operator(OperatorType.RB, ")"));
                                    break;
                                }
                            }
                            //函数数量减少
                            if (funcCount > 0)
                            {
                                funcCount--;
                            }
                        }
                        else
                        {
                            //分析并存入运算符到语法单元堆栈
                            if (currentOpd != "")
                            {
                                operandType = this.ConvertOperand(currentOpd);
                                if ((operandType != OperandType.STRING) || (funcCount > 0))
                                {
                                    //lizheng add
                                    if (operandType == OperandType.STRING)
                                    {
                                        Operand opd = new Operand(ConvertOperand(currentOpd), currentOpd);
                                        if (this.OnAccidenceAnalysis == null)
                                        {
                                            tokens.Push(opd);
                                        }
                                        else
                                        {
                                            if (OnAccidenceAnalysis(ref opd))
                                            {
                                                tokens.Push(opd);
                                            }
                                            else
                                            {
                                                m_Message = "解析操作数:" + Convert.ToString(opd.Value) + "失败";
                                                tokens.Clear();
                                                return false;
                                            }
                                        }
                                    }
                                    //
                                    else
                                    {
                                        tokens.Push(new Operand(ConvertOperand(currentOpd), currentOpd));
                                    }
                                }
                                else
                                {
                                    Operand opd = new Operand(ConvertOperand(currentOpd), currentOpd);
                                    if (this.OnAccidenceAnalysis == null)
                                    {
                                        tokens.Push(opd);
                                    }
                                    else
                                    {
                                        if (OnAccidenceAnalysis(ref opd))
                                        {
                                            tokens.Push(opd);
                                        }
                                        else
                                        {
                                            m_Message = "解析操作数:" + Convert.ToString(opd.Value) + "失败";
                                            tokens.Clear();
                                            return false;
                                        }
                                    }
                                }
                            }
                            //调整运算符
                            currentOpt = this.AdjustOperator(currentOpt, exp, currentPos, out currentPos);
                            if (isNS)
                            {
                                operatorType = this.ConvertOperator(currentOpt, false);
                            }
                            else
                            {
                                operatorType = this.ConvertOperator(currentOpt, this.IsDyadicOperator(ref tokens, ref operators, currentOpd));
                            }
                            //分析并存入操作数到操作数堆栈
                            if (operatorType == OperatorType.ERR)
                            {
                                m_Message = "无效运算符:" + currentOpt;
                                tokens.Clear();
                                return false;
                            }
                            else
                            {
                                if (operators.Count == 0)
                                {
                                    //若运算符堆栈为空,则直接存入.
                                    operators.Push(new Operator(operatorType, currentOpt));
                                }
                                else
                                {
                                    if (operators.Peek().Type == OperatorType.LB)
                                    {
                                        //若运算符堆栈栈顶为左括号,则将当前运算符直接存入运算符堆栈.
                                        operators.Push(new Operator(operatorType, currentOpt));
                                    }
                                    else
                                    {
                                        if (OperatorPriority(operatorType, operators.Peek().Type) > 0)
                                        {
                                            //若当前运算符比运算符栈顶运算符优先级高,则将当前运算符直接存入运算符堆栈.
                                            operators.Push(new Operator(operatorType, currentOpt));
                                        }
                                        else
                                        {
                                            //若当前运算符比运算符堆栈栈顶运算符优先级低或相等,则弹出运算符堆栈栈顶运算符并存入到语法单元堆栈,并将当前运算符存入堆栈.
                                            tokens.Push(operators.Pop());
                                            operators.Push(new Operator(operatorType, currentOpt));
                                        }
                                    }
                                }
                            }
                        }
                        exp = exp.Substring(currentPos + 1).Trim();
                    }
                }
                //转换完成,若运算符堆栈中尚有运算符时,
                //则依序取出运算符到语法单元堆栈,直到运算符堆栈为空
                while (operators.Count > 0)
                {
                    tokens.Push(operators.Pop());
                }
                //调整语法单元中对象的顺序并输出到最终语法单元
                while (tokens.Count > 0)
                {
                    m_tokens.Push(tokens.Pop());
                }
            }
            return true;
        }



        /// <summary>
        /// 对逆波兰表达式求值
        /// </summary>
        /// <param name="isOk">是否成功</param>
        /// <returns>结果值</returns>
        public object Evaluate(ref bool isOk)
        {
            /*
              逆波兰表达式求值算法：
              1、循环扫描语法单元的项目。
              2、如果扫描的项目是操作数，则将其压入操作数堆栈，并扫描下一个项目。
              3、如果扫描的项目是一个二元运算符，则对栈的顶上两个操作数执行该运算。
              4、如果扫描的项目是一个一元运算符，则对栈的最顶上操作数执行该运算。
              5、将运算结果重新压入堆栈。
              6、重复步骤2-5，堆栈中即为结果值。
            */

            if (m_tokens.Count == 0) return null;

            isOk = false;
            object value = null;
            bool existFunc = false;
            Stack<Operand> opds = new Stack<Operand>();
            Stack<object> pars = new Stack<object>();
            Operand opd, opdA, opdB;

            foreach (object item in m_tokens)
            {
                if (item is Operand)
                {
                    //如果为操作数则压入操作数堆栈
                    opds.Push((Operand)item);
                }
                else
                {
                    switch (((Operator)item).Type)
                    {
                        #region 左括号
                        case OperatorType.LB:

                            if (opds.Count > 0)
                            {
                                //清除函数参数堆栈
                                pars.Clear();
                                //检查是否有函数调用
                                existFunc = false;
                                foreach (Operand opdItem in opds)
                                {
                                    if (opdItem.Type == OperandType.FUNC)
                                    {
                                        existFunc = true;
                                        break;
                                    }
                                }
                                //将函数参数压入堆栈
                                if (existFunc)
                                {
                                    while (opds.Count > 0)
                                    {
                                        opd = opds.Peek();
                                        if (opd.Type != OperandType.FUNC)
                                        {
                                            opd = opds.Pop();
                                            pars.Push(opd.Value);
                                        }
                                        else
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region 右括号
                        case OperatorType.RB:
                            if (pars.Count > 0)
                            {
                                object val;
                                bool ok = false;
                                if (this.OnCallBack != null)
                                {
                                    val = OnCallBack(Convert.ToString(opds.Pop().Value), pars.ToArray(), ref ok);
                                    if (ok)
                                    {
                                        opds.Push(new Operand(OperandType.NUMBER, val));
                                    }
                                }
                                pars.Clear();
                            }
                            break;
                        #endregion

                        #region 逻辑非,!,NOT
                        case OperatorType.NOT:
                            opdA = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value))
                            {
                                opds.Push(new Operand(OperandType.BOOLEAN, !ConvertToBoolean(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 正号,+,positive sign
                        case OperatorType.PS:
                            opdA = opds.Pop();
                            if (IsNumber(opdA.Value))
                            {

                                opds.Push(new Operand(OperandType.NUMBER, +ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 负号,-,negative sign
                        case OperatorType.NS:
                            opdA = opds.Pop();
                            if (IsNumber(opdA.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, -ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 乘,*,multiplication
                        case OperatorType.MUL:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsNumber(opdA.Value) && IsNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) * ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 除,/,division
                        case OperatorType.DIV:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsNumber(opdA.Value) && IsNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) / ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 余,%,modulus
                        case OperatorType.MOD:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsNumber(opdA.Value) && IsNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) % ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 加,+,Addition
                        case OperatorType.ADD:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsNumber(opdA.Value) && IsNumber(opdB.Value))//函数内部都是数字时直接运算，如果有变量则进入else，现在没有处理呢！李正！！
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) + ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 减,-,subtraction
                        case OperatorType.SUB:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsNumber(opdA.Value) && IsNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) - ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 小于,less than
                        case OperatorType.LT:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value) && IsCanConvertToNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) < ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 小于或等于,less than or equal to
                        case OperatorType.LE:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value) && IsCanConvertToNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) <= ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 大于,>,greater than
                        case OperatorType.GT:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value) && IsCanConvertToNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) > ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 大于或等于,>=,greater than or equal to
                        case OperatorType.GE:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value) && IsCanConvertToNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) >= ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 等于,=,equal to
                        case OperatorType.ET:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value) && IsCanConvertToNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) == ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 不等于,unequal to
                        case OperatorType.UT:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value) && IsCanConvertToNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToNumber(opdB.Value) != ConvertToNumber(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 逻辑与,&,AND
                        case OperatorType.AND:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value) && IsCanConvertToNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToBoolean(opdB.Value) && ConvertToBoolean(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 逻辑或,|,OR
                        case OperatorType.OR:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            if (IsCanConvertToNumber(opdA.Value) && IsCanConvertToNumber(opdB.Value))
                            {
                                opds.Push(new Operand(OperandType.NUMBER, ConvertToBoolean(opdB.Value) || ConvertToBoolean(opdA.Value)));
                            }
                            else
                            {

                            }
                            break;
                        #endregion

                        #region 逗号,comma
                        case OperatorType.CA:
                            opdA = opds.Pop();
                            opdB = opds.Pop();
                            opds.Push(new Operand(opdB.Type, opdB.Value));
                            opds.Push(new Operand(opdA.Type, opdA.Value));
                            break;
                        #endregion

                        #region 结束符号
                        case OperatorType.END:
                            break;
                        #endregion

                        #region 错误符号
                        case OperatorType.ERR:
                            break;
                        #endregion
                    }
                }
            }
            if (opds.Count > 0)
            {
                if (opds.Count == 1)
                {
                    isOk = true;
                    value = opds.Pop().Value;
                }
            }
            return value;
        }



        /// <summary>
        /// 从表达式中查找运算符位置
        /// </summary>
        /// <param name="exp">表达式</param>
        /// <returns>返回运算符位置</returns>
        private int FindOperator(string exp)
        {
            return FindOperator(exp, "");
        }

        /// <summary>
        /// 从表达式中查找运算符位置
        /// </summary>
        /// <param name="exp">表达式</param>
        /// <param name="findOpt">要查找的运算符</param>
        /// <returns>返回运算符位置</returns>
        private int FindOperator(string exp, string findOpt)
        {
            string opt = "";
            string chr = "";

            for (int i = 0; i < exp.Length; i++)
            {
                chr = exp.Substring(i, 1);
                if ("\"'#".Contains(chr))//忽略双引号、单引号、井号中的运算符
                {
                    if (opt.Contains(chr))
                    {
                        opt = opt.Remove(opt.IndexOf(chr), 1);
                    }
                    else
                    {
                        opt += chr;
                    }
                }
                if (opt == "")
                {
                    if (findOpt != "")
                    {
                        if (findOpt == chr)
                        {
                            return i;
                        }
                    }
                    else
                    {
                        if (m_Operator.IndexOf(chr) > -1)
                        {
                            return i;
                        }
                    }
                }
            }
            return -1;
        }

        /// <summary>
        /// 检查表达式中特殊符号是否匹配
        /// </summary>
        /// <returns>匹配返回真</returns>
        private bool IsMatching(string exp)
        {
            string opt = "";
            string chr = "";

            for (int i = 0; i < exp.Length; i++)
            {
                chr = exp.Substring(i, 1);
                if ("\"'#".Contains(chr))//忽略双引号、单引号、井号中的运算符
                {
                    if (opt.Contains(chr))
                    {
                        opt = opt.Remove(opt.IndexOf(chr), 1);
                    }
                    else
                    {
                        opt += chr;
                    }
                }
                else if ("()".Contains(chr))//左右括号要成对匹配
                {
                    if (chr == "(")
                    {
                        opt += chr;
                    }
                    else if (chr == ")")
                    {
                        if (opt.Contains("("))
                        {
                            opt = opt.Remove(opt.IndexOf("("), 1);
                        }
                    }
                }
            }
            return (opt == "");
        }

        /// <summary>
        /// 转换操作数到指定的类型
        /// </summary>
        /// <param name="opd">操作数</param>
        /// <returns>返回制定的操作数类型</returns>
        private OperandType ConvertOperand(string opd)
        {
            if (opd.IndexOf("(") > -1)
            {
                return OperandType.FUNC;
            }
            else if (this.IsNumber(opd))
            {
                return OperandType.NUMBER;
            }
            else if (this.IsDate(opd))
            {
                return OperandType.DATE;
            }
            else
            {
                return OperandType.STRING;
            }
        }

        /// <summary>
        /// 转换运算符到指定的类型
        /// </summary>
        /// <param name="opt">运算符</param>
        /// <param name="isDyadicOperator">是否为二元运算符</param>
        /// <returns>返回制定的运算符类型</returns>
        private OperatorType ConvertOperator(string opt, bool isDyadicOperator)
        {
            switch (opt)
            {
                case "!": return OperatorType.NOT;
                case "+": return isDyadicOperator ? OperatorType.ADD : OperatorType.PS;
                case "-": return isDyadicOperator ? OperatorType.SUB : OperatorType.NS;
                case "*": return isDyadicOperator ? OperatorType.MUL : OperatorType.ERR;
                case "/": return isDyadicOperator ? OperatorType.DIV : OperatorType.ERR;
                case "%": return isDyadicOperator ? OperatorType.MOD : OperatorType.ERR;
                case "<": return isDyadicOperator ? OperatorType.LT : OperatorType.ERR;
                case ">": return isDyadicOperator ? OperatorType.GT : OperatorType.ERR;
                case "<=": return isDyadicOperator ? OperatorType.LE : OperatorType.ERR;
                case ">=": return isDyadicOperator ? OperatorType.GE : OperatorType.ERR;
                case "<>": return isDyadicOperator ? OperatorType.UT : OperatorType.ERR;
                case "=": return isDyadicOperator ? OperatorType.ET : OperatorType.ERR;
                case "&": return isDyadicOperator ? OperatorType.AND : OperatorType.ERR;
                case "|": return isDyadicOperator ? OperatorType.OR : OperatorType.ERR;
                case ",": return isDyadicOperator ? OperatorType.CA : OperatorType.ERR;
                case "": return isDyadicOperator ? OperatorType.END : OperatorType.ERR;
                default: return OperatorType.ERR;
            }
        }

        /// <summary>
        /// 运算符是否为二元运算符
        /// </summary>
        /// <param name="tokens">语法单元堆栈</param>
        /// <param name="operators">运算符堆栈</param>
        /// <param name="currentOpd">当前操作数</param>
        /// <returns>是返回真,否返回假</returns>
        private bool IsDyadicOperator(ref Stack<object> tokens, ref Stack<Operator> operators, string currentOpd)
        {
            if (currentOpd != "")
            {
                return true;
            }
            else
            {
                if (tokens.Count == 0)
                {
                    return false;
                }
                object token = tokens.Peek();
                if (token is Operand)
                {
                    if (operators.Peek().Type != OperatorType.LB)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    if (((Operator)token).Type == OperatorType.RB)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
        }

        /// <summary>
        /// 调整运算符
        /// </summary>
        /// <param name="currentOpt">当前运算符</param>
        /// <param name="currentExp">当前表达式</param>
        /// <param name="currentOptPos">当前运算符位置</param>
        /// <param name="adjustOptPos">调整后运算符位置</param>
        /// <returns>返回调整后的运算符</returns>
        private string AdjustOperator(string currentOpt, string currentExp, int currentOptPos, out int adjustOptPos)
        {
            switch (currentOpt)
            {
                case "<":
                    if (currentExp.Substring(currentOptPos, 2) == "<=")
                    {
                        adjustOptPos = currentOptPos + 1;
                        return "<=";
                    }
                    else if (currentExp.Substring(currentOptPos, 2) == "<>")
                    {
                        adjustOptPos = currentOptPos + 1;
                        return "<>";
                    }
                    else
                    {
                        adjustOptPos = currentOptPos;
                        return "<";
                    }

                case ">":
                    if (currentExp.Substring(currentOptPos, 2) == ">=")
                    {
                        adjustOptPos = currentOptPos + 1;
                        return ">=";
                    }
                    else
                    {
                        adjustOptPos = currentOptPos;
                        return ">";
                    }

                default:
                    adjustOptPos = currentOptPos;
                    return currentOpt;
            }
        }

        /// <summary>
        /// 运算符优先级比较
        /// </summary>
        /// <param name="optA">运算符类型A</param>
        /// <param name="optB">运算符类型B</param>
        /// <returns>-1，低；0,相等；1，高</returns>
        private int OperatorPriority(OperatorType optA, OperatorType optB)
        {
            if (optA == optB)
            {
                //A、B优先级相等
                return 0;
            }
            else if (optA > optB)
            {
                //A优先级低于B
                return -1;
            }
            else
            {
                //乘,除,余(*,/,%)
                if ((optA >= OperatorType.MUL && optA <= OperatorType.MOD) &&
                    (optB >= OperatorType.MUL && optB <= OperatorType.MOD))
                {
                    return 0;
                }
                //加,减(+,-)
                if ((optA >= OperatorType.ADD && optA <= OperatorType.SUB) &&
                    (optB >= OperatorType.ADD && optB <= OperatorType.SUB))
                {
                    return 0;
                }
                //小于,小于或等于,大于,大于或等于(<,<=,>,>=)
                if ((optA >= OperatorType.LT && optA <= OperatorType.GE) &&
                    (optB >= OperatorType.LT && optB <= OperatorType.GE))
                {
                    return 0;
                }
                //等于,不等于(=,<>)
                if ((optA >= OperatorType.ET && optA <= OperatorType.UT) &&
                    (optB >= OperatorType.ET && optB <= OperatorType.UT))
                {
                    return 0;
                }
                //A优先级高于B
                return 1;
            }
        }

        /// <summary>
        /// 判断对象是否为数字
        /// </summary>
        /// <param name="value">对象值</param>
        /// <returns>是返回真,否返回假</returns>
        private bool IsNumber(object value)
        {
            decimal dec;
            return decimal.TryParse(Convert.ToString(value), out dec);
        }

        /// <summary>
        /// 判断对象是否为日期
        /// </summary>
        /// <param name="value">对象值</param>
        /// <returns>是返回真,否返回假</returns>
        private bool IsDate(object value)
        {
            DateTime dt;
            return DateTime.TryParse(Convert.ToString(value), out dt);
        }

        /// <summary>
        /// 判断对象是否为布尔型
        /// </summary>
        /// <param name="value">对象值</param>
        /// <returns>是返回真,否返回假</returns>
        private bool IsBoolean(object value)
        {
            bool b = false;
            return Boolean.TryParse(Convert.ToString(value), out b);
        }

        /// <summary>
        /// 判断对象是否可转换成数字
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        private bool IsCanConvertToNumber(object value)
        {
            return (IsNumber(value) || IsBoolean(value));
        }

        /// <summary>
        /// 将对象转换成数字
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        private decimal ConvertToNumber(object value)
        {
            return Convert.ToDecimal(value);
        }

        /// <summary>
        /// 将对象转换成布尔型
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        private bool ConvertToBoolean(object value)
        {
            if (value is bool)
            {
                return (bool)value;
            }
            else
            {
                if (Convert.ToDecimal(value) != 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
    }
}