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;
}
}
}
}
}