private static 运算符 Get_优先级最小的左右结合运算符和右结合运算符(char[] chars, int beginIndex, int endIndex)
{
List <表达式段> list = Parser._小括号中括号单引号双引号_分段(chars, beginIndex, endIndex);
list = 继续把普通段分为运算符段和普通段(chars, list);
list = Parser.去掉空白段(chars, list);
表达式段 表达式段;
运算符 op1 = null, op2;
for (int i = 0; i < list.Count; i++)
{
表达式段 = list[i];
if (表达式段.type == 表达式段_Type.小括号段)
{
op2 = Check_IsCast(chars, 表达式段);
}
else if (表达式段.type == 表达式段_Type.运算符段)
{
op2 = Get_运算符(chars, list, i);
}
else
{
op2 = null;
}
if (op2 == null)
{
continue;
}
if (op1 == null || op2.优先级 < op1.优先级)
{
op1 = op2;
}
}
return(op1);
}
public static 表达式 Parse(char[] chars, int beginIndex, int endIndex)
{
StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);
if (span.isEmpty)
{
throw new InnerCException("无效的表达式 。 缺少内容 。", chars, beginIndex);
}
//List<表达式段> list = 按_小括号中括号双引号单引号_分段(chars, span.iLeft, span.iRight);
运算符 op = Get_优先级最小的左右结合运算符和右结合运算符(chars, span.iLeft, span.iRight);
if (op == null)
{
return(常量_变量_字段_指针字段_数组元素_函数调用_函数指针调用_调用链_Parser.Parse(chars, span.iLeft, span.iRight));
}
表达式 op_左边的表达式 = null;
表达式 op_右边的表达式;
if (op.op == "!" || op.type == 运算符_Type.Cast || op.type == 运算符_Type.指针取值 || op.type == 运算符_Type.取地址)
{
StrSpan 左边的内容 = StrUtil.Trim(chars, span.iLeft, op.iLeft - 1, Parser._whiteSpaces);
if (!左边的内容.isEmpty)
{
throw new InnerCException("无效的内容，缺少运算符 。", chars, 左边的内容.iRight);
}
op_右边的表达式 = Parse(chars, op.iRight + 1, endIndex);
}
else
{
op_左边的表达式 = Parse(chars, span.iLeft, op.iLeft - 1);
op_右边的表达式 = Parse(chars, op.iRight + 1, endIndex);
}
if (op.type == 运算符_Type.Cast)
{
return(new Cast(op.castType, op_右边的表达式));
}
if (op.type == 运算符_Type.指针取值)
{
return(new 指针取值(op_右边的表达式));
}
if (op.type == 运算符_Type.取地址)
{
return(new 取地址(op_右边的表达式));
}
if (op.op == "+")
{
return(new 加(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "-")
{
return(new 减(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "*")
{
return(new 乘(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "/")
{
return(new 除(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "==")
{
return(new 等于(op_左边的表达式, op_右边的表达式));
}
else if (op.op == ">")
{
return(new 大于(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "<")
{
return(new 小于(op_左边的表达式, op_右边的表达式));
}
else if (op.op == ">=")
{
return(new 大于等于(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "<=")
{
return(new 小于等于(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "!=")
{
return(new 等于(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "&&")
{
return(new 与(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "||")
{
return(new 或(op_左边的表达式, op_右边的表达式));
}
else if (op.op == "!")
{
return(new 非(op_右边的表达式));
}
else if (op.op == "=")
{
return(new 赋值(op_左边的表达式, op_右边的表达式));
}
throw new InnerCException("无效的运算符 \"" + op.op + "\" 。", chars, op.iLeft);
}
