//private static 表达式 Parse_函数指针调用(char[] chars, List<表达式段> list)
//{
// if (list.Count < 2)
// return null;
// 表达式段 段 = list[list.Count - 1];
// if (段.type != 表达式段_Type.小括号段)
// return null;
// 表达式 express = Parse(chars, list[0].iLeft, 段.iLeft - 1);
// //指针取值 指针取值 = express as 指针取值;
// //if (指针取值 == null)
// // return null;
// List<表达式> list实参 = Parse_实参(chars, 段);
// //return new 函数指针调用(指针取值, list实参);
// return new 函数指针调用(express, list实参);
//}
private static List <表达式> Parse_实参(char[] chars, 表达式段 段)
{
List <表达式> list实参 = new List <表达式>();
List <StrSpan> list = 在_小括号中括号单引号双引号_之外用逗号_Split(chars, 段.iLeft + 1, 段.iRight - 1);
if (list.Count == 1 && list[0].isEmpty)
{
return(list实参);
}
StrSpan span;
for (int i = 0; i < list.Count; i++)
{
span = list[i];
if (span.isEmpty)
{
throw new 语法错误_Exception("缺少参数 。", chars, span.iLeft);
}
}
for (int i = 0; i < list.Count; i++)
{
span = list[i];
list实参.Add(表达式_Parser.Parse(chars, span.iLeft, span.iRight));
}
return(list实参);
}
private static 表达式 Parse_变量(char[] chars, List <表达式段> list)
{
if (list.Count > 1)
{
return(null);
}
表达式段 段 = list[0];
if (段.type != 表达式段_Type.普通段)
{
return(null);
}
if (!Util.Check_是否_下划线字母数字_且以_下划线字母_开头(chars, 段.iLeft, 段.iRight))
{
return(null);
}
string name = new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1);
变量 变量 = new 变量(name, chars, 段.iLeft);
//变量.参考位置_iLeft = 段.iLeft;
return(变量);
}
private static 运算符 Get_运算符(char[] chars, List <表达式段> list, int i)
{
表达式段 段 = list[i];
string op = new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1);
if (op == "*")
{
if (i == 0 || list[i - 1].type == 表达式段_Type.运算符段)
{
return(new 运算符(op, 运算符_Type.指针取值, 6, null, 段.iLeft, 段.iRight));
}
}
if (op == "&")
{
if (i == 0 || list[i - 1].type == 表达式段_Type.运算符段)
{
return(new 运算符(op, 运算符_Type.取地址, 6, null, 段.iLeft, 段.iRight));
}
}
if (op == "==" || op == ">=" || op == "<=" || op == "!=" || op == ">" || op == "<")
{
return(new 运算符(op, 3, 段.iLeft, 段.iRight));
}
if (op == "&&")
{
return(new 运算符(op, 2, 段.iLeft, 段.iRight));
}
if (op == "||")
{
return(new 运算符(op, 1, 段.iLeft, 段.iRight));
}
if (op == "!")
{
return(new 运算符(op, 6, 段.iLeft, 段.iRight));
}
if (op == "*" || op == "/")
{
return(new 运算符(op, 5, 段.iLeft, 段.iRight));
}
if (op == "+" || op == "-")
{
return(new 运算符(op, 4, 段.iLeft, 段.iRight));
}
if (op == "=")
{
return(new 运算符(op, 0, 段.iLeft, 段.iRight));
}
throw new InnerCException("未知的运算符 ： \"" + new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1) + "\" 。", chars, 段.iLeft);
}
private static 表达式 Parse_指针字段(char[] chars, List <表达式段> list)
{
表达式段 段 = list[list.Count - 1];
if (段.type != 表达式段_Type.普通段)
{
return(null);
}
string 点或箭头;
int 点或箭头的位置 = 寻找最右边的点或箭头的位置(chars, 段.iLeft, 段.iRight, out 点或箭头);
if (点或箭头的位置 == -1)
{
return(null);
}
if (点或箭头 != "->")
{
return(null);
}
StrSpan 右边的部分 = StrUtil.Trim(chars, 点或箭头的位置 + 2, 段.iRight, Parser._whiteSpaces);
if (右边的部分.isEmpty)
{
throw new 语法错误_Exception("\".\" 后面缺少 字段名 。", chars, 点或箭头的位置);
}
StrSpan 左边的部分 = StrUtil.Trim(chars, 段.iLeft, 点或箭头的位置 - 1, Parser._whiteSpaces);
if (左边的部分.isEmpty)
{
throw new 语法错误_Exception("\".\" 前面缺少 变量 或者 表达式 。", chars, 点或箭头的位置);
}
表达式 express = Parse(chars, 左边的部分.iLeft, 左边的部分.iRight);
//if (!(express is 变量 || express is 指针取值))
// throw new InnerCException("\".\" 前面应该是 变量 或者 指针取值 表达式 。", chars, 左边的部分.iRight);
if (!Util.Check_是否_下划线字母数字_且以_下划线字母_开头(chars, 右边的部分.iLeft, 右边的部分.iRight))
{
throw new 语法错误_Exception("无效的字段名 。", chars, 右边的部分.iLeft);
}
return(new 指针字段(express, new string(chars, 右边的部分.iLeft, 右边的部分.iRight - 右边的部分.iLeft + 1), chars, 点或箭头的位置));
}
private static 表达式 Parse_常量(char[] chars, List <表达式段> list)
{
if (list.Count > 1)
{
return(null);
}
表达式段 段 = list[0];
if (段.type == 表达式段_Type.单引号段)
{
return(new 常量(常量_Type._char, new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1), chars, 段.iLeft));
}
if (段.type == 表达式段_Type.双引号段)
{
return(new 常量(常量_Type._String, new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1), chars, 段.iLeft));
}
if (段.type == 表达式段_Type.中括号段)
{
return(new 常量(常量_Type.中括号数组常量, new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1), chars, 段.iLeft));
}
if (段.type != 表达式段_Type.普通段)
{
return(null);
}
StrSpan span = StrUtil.Trim(chars, 段.iLeft, 段.iRight, Parser._whiteSpaces);
if (span.isEmpty)
{
return(null);
}
if (Util.Check_int(chars, span.iLeft, span.iRight))
{
return(new 常量(常量_Type._int, new string(chars, span.iLeft, span.iRight - span.iLeft + 1), chars, span.iLeft));
}
if (Util.Check_float(chars, span.iLeft, span.iRight))
{
return(new 常量(常量_Type._float, new string(chars, span.iLeft, span.iRight - span.iLeft + 1), chars, span.iLeft));
}
return(null);
}
private static 表达式 Parse_小括号表达式(char[] chars, List <表达式段> list)
{
if (list.Count > 1)
{
return(null);
}
表达式段 段 = list[0];
if (段.type != 表达式段_Type.小括号段)
{
return(null);
}
return(表达式_Parser.Parse(chars, 段.iLeft + 1, 段.iRight - 1));
}
private static 运算符 Check_IsCast(char[] chars, 表达式段 段)
{
StrSpan span = StrUtil.Trim(chars, 段.iLeft + 1, 段.iRight - 1, Parser._whiteSpaces);
if (span.isEmpty)
{
return(null);
}
if (!Util.Check_是否_下划线字母数字_且以_下划线字母_开头(chars, span.iLeft, span.iRight))
{
return(null);
}
string op = new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1);
string castType = new string(chars, span.iLeft, span.iRight - span.iLeft + 1);
return(new 运算符(op, 运算符_Type.Cast, 6, castType, 段.iLeft, 段.iRight));
}
private static 表达式 Parse_函数调用(char[] chars, List <表达式段> list)
{
if (list.Count < 2)
{
return(null);
}
表达式段 段 = list[list.Count - 1];
if (段.type != 表达式段_Type.小括号段)
{
return(null);
}
表达式 左边的表达式 = Parse(chars, list[0].iLeft, 段.iLeft - 1);
变量 函数名 = 左边的表达式 as 变量;
if (函数名 != null)
{
List <表达式> list实参 = Parse_实参(chars, 段);
return(new 函数调用(函数名.name, list实参, chars, 段.iLeft));
}
指针取值 指针取值 = 左边的表达式 as 指针取值;
if (指针取值 != null)
{
List <表达式> list实参 = Parse_实参(chars, 段);
return(new 函数指针调用(指针取值, list实参, chars, 段.iLeft));
}
throw new 语法错误_Exception("函数调用 左边应该是 函数名 或者 指针取值 表达式 如 (* p) 。", chars, 段.iLeft);
//if (指针取值 == null)
// return null;
//return new 函数调用(左边的表达式, list实参);
}
public static void 把普通段分为运算符段和普通段(char[] chars, 表达式段 表达式段, List <表达式段> listNew)
{
char c1, c2;
int p = 表达式段.iLeft;
for (int i = 表达式段.iLeft; i <= 表达式段.iRight; i++)
{
c1 = chars[i];
if (i < 表达式段.iRight)
{
c2 = chars[i + 1];
if (c1 == '-' && c2 == '>')
{
i = i + 2;
p = 2;
continue;
}
if (c1 == '=' && c2 == '=' || c1 == '>' && c2 == '=' || c1 == '<' && c2 == '=' ||
c1 == '!' && c2 == '=' || c1 == '&' && c2 == '&' || c1 == '|' && c2 == '|')
{
if (p <= i - 1)
{
listNew.Add(new 表达式段(p, i - 1, 表达式段_Type.普通段));
}
listNew.Add(new 表达式段(i, i + 1, 表达式段_Type.运算符段));
i = i + 2;
p = i;
continue;
}
}
if (c1 == '+' || c1 == '-' || c1 == '*' || c1 == '/' || c1 == '>' || c1 == '<' || c1 == '!' ||
c1 == '=' || c1 == '&')
{
if (p <= i - 1)
{
listNew.Add(new 表达式段(p, i - 1, 表达式段_Type.普通段));
}
listNew.Add(new 表达式段(i, i, 表达式段_Type.运算符段));
i = i + 1;
p = i;
}
}
if (p <= 表达式段.iRight)
{
listNew.Add(new 表达式段(p, 表达式段.iRight, 表达式段_Type.普通段));
}
}
