public static 结构体 Parse(char[] chars, 第一层_代码块 代码块)
{
StrSpan span = StrUtil.Trim(chars, 代码块.iLeft, 代码块.iRight, Parser._whiteSpaces);
int struct关键字位置;
int j = 代码块.大括号块.iLeft - 1;
while (true)
{
struct关键字位置 = StrUtil.FindBackward(chars, span.iLeft, j, "struct");
if (struct关键字位置 == -1)
{
return(null);
}
if (StrUtil.IsOneOf(chars[struct关键字位置 + 6], Parser._whiteSpaces))
{
break;
}
j = struct关键字位置 - 1;
}
StrSpan span结构体名 = StrUtil.Trim(chars, struct关键字位置 + 6, 代码块.大括号块.iLeft - 1, Parser._whiteSpaces);
Dictionary <string, 字段声明> dic字段声明 = Parse_字段声明(chars, 代码块.大括号块);
string 结构体名 = new string(chars, span结构体名.iLeft, span结构体名.iRight - span结构体名.iLeft + 1);
return(new 结构体(结构体名, dic字段声明, span结构体名.iLeft));
}
public static 结构体 Parse(char[] chars, 第一层_代码块 代码块)
{
StrSpan span = StrUtil.Trim(chars, 代码块.iLeft, 代码块.iRight, Parser._whiteSpaces);
int struct关键字位置;
int j = 代码块.大括号块.iLeft - 1;
while (true)
{
struct关键字位置 = StrUtil.FindBackward(chars, span.iLeft, j, "struct");
if (struct关键字位置 == -1)
{
return(null);
}
if (StrUtil.IsOneOf(chars[struct关键字位置 + 6], Parser._whiteSpaces))
{
break;
}
j = struct关键字位置 - 1;
}
StrSpan span结构体名 = StrUtil.Trim(chars, struct关键字位置 + 6, 代码块.大括号块.iLeft - 1, Parser._whiteSpaces);
if (span结构体名.isEmpty)
{
throw new 语法错误_Exception("缺少 结构体名 。", chars, struct关键字位置 + 6);
}
string 结构体名 = new string(chars, span结构体名.iLeft, span结构体名.iRight - span结构体名.iLeft + 1);
if (!Util.Check_是否_下划线字母数字_且以_下划线字母_开头(结构体名))
{
throw new 语法错误_Exception("无效的 结构体名 \"" + 结构体名 + "\"，结构体名 应由 下划线字母数字 组成且以 下划线或字母 开头 。", chars, span结构体名.iLeft);
}
if (Util.Check_是否关键字(结构体名))
{
throw new 语法错误_Exception("无效的 结构体名 \"" + 结构体名 + "\"，结构体名 不能和 关键字 相同 。", chars, span结构体名.iLeft);
}
//Dictionary<string, 字段声明> dic字段声明 = Parse_字段声明(chars, 代码块.大括号块);
作用域 字段声明 = Parse_字段声明(chars, 代码块.大括号块);
return(new 结构体(结构体名, 字段声明, span结构体名.iLeft));
//return new 结构体(结构体名, dic字段声明, span结构体名.iLeft);
}
private static void Parse(ParseResult r, char[] chars, 第一层_代码块 代码块)
{
if (代码块.type == 第一层_代码块_Type.全局变量块)
{
Parse_全局变量(r, chars, 代码块);
return;
}
结构体 结构体 = 结构体_Parser.Parse(chars, 代码块);
if (结构体 != null)
{
if (r.dic结构体.ContainsKey(结构体.name))
{
throw new 语法错误_Exception("结构体名 \"" + 结构体.name + "\" 重复 。", chars, 结构体.结构体名_iLeft);
}
//结构体.Set_全局成员(r);
结构体.Set_作用域(r.全局变量);
r.dic结构体.Add(结构体.name, 结构体);
return;
}
函数 函数 = 函数_Parser.Parse(chars, 代码块);
if (r.dic函数.ContainsKey(函数.name))
{
throw new 语法错误_Exception("函数名 \"" + 函数.name + "\" 重复 。", chars, 函数.函数名_iLeft);
}
//函数.Set_全局成员(r);
函数.Set_作用域(r.全局变量);
r.dic函数.Add(函数.name, 函数);
}
private static void Parse_全局变量(ParseResult r, char[] chars, 第一层_代码块 代码块)
{
//块作用域 块 = 语句_Parser.Parse_块作用域(chars, 代码块.iLeft, 代码块.iRight);
List <StrSpan> list = Parser.在_单引号双引号_以外_Split(chars, 代码块.iLeft, 代码块.iRight, ';');
StrSpan span;
for (int i = 0; i < list.Count; i++)
{
span = list[i];
if (span.isEmpty)
{
continue;
}
if (i == list.Count - 1)
{
throw new 语法错误_Exception("未结束的语句，缺少分号 \";\" 。", chars, span.iRight);
}
变量声明和初始化 变量声明 = 语句_Parser.Parse_变量声明(chars, span.iLeft, span.iRight);
if (变量声明 == null)
{
throw new 语法错误_Exception("无效的表达式 。", chars, span.iLeft);
}
r.全局变量.Add_变量定义(变量声明, chars);
//if (r.dic全局变量.ContainsKey(变量声明.name))
//if (r.全局变量.dic变量声明.ContainsKey(变量声明.name))
// throw new 语法错误_Exception("已定义了名为 \"" + 变量声明.name + "\" 的 全局变量 。", chars, 变量声明.变量名位置);
//r.全局变量.dic变量声明.Add(变量声明.name, 变量声明.To_全局变量());
//r.dic全局变量.Add(变量声明.name, 变量声明.To_全局变量());
}
}
public static 函数 Parse(char[] chars, 第一层_代码块 代码块)
{
//int i;
//int beginIndex = 上一个大括号块 == null ? 0 : 上一个大括号块.iRight + 1;
//int endIndex = 大括号块.iLeft - 1;
//i = Parser.从右向左寻找_分号_单引号_双引号(chars, beginIndex, endIndex);
//if (i != -1)
// beginIndex = i + 1;
//StrSpan span = new StrSpan(beginIndex, 大括号块.iRight);
//int args_beginIndex;
//int args_endIndex;
StrSpan span = StrUtil.Trim(chars, 代码块.iLeft, 代码块.iRight, Parser._whiteSpaces);
int 右小括号位置 = StrUtil.FindBackwardUntilNot(chars, span.iLeft, 代码块.大括号块.iLeft - 1, Parser._whiteSpaces);
if (右小括号位置 == -1)
{
throw new 语法错误_Exception("函数定义错误： 函数头为空 。", chars, 代码块.大括号块.iLeft - 1);
}
if (chars[右小括号位置] != ')')
{
throw new 语法错误_Exception("函数定义错误： 函数头 缺少 右小括号 \"(\" 。", chars, 右小括号位置);
}
//int 右小括号位置 = StrUtil.FindBackward(chars, 代码块.iLeft, 代码块.大括号块.iLeft - 1, ')');
//if (右小括号位置 == -1)
// throw new InnerCException("函数定义错误： 函数头 缺少 右小括号 \"(\" 。", chars, beginIndex - 1);
//args_endIndex = i - 1;
//beginIndex = i - 1;
int 左小括号位置 = StrUtil.FindBackward(chars, span.iLeft, 右小括号位置 - 1, '(');
if (左小括号位置 == -1)
{
throw new 语法错误_Exception("函数定义错误： 函数头 缺少 左小括号 \"(\" 。", chars, span.iLeft);
}
int 函数名结束位置 = StrUtil.FindBackwardUntilNot(chars, span.iLeft, 左小括号位置 - 1, Parser._whiteSpaces);
if (!Util.Check_是否_下划线字母数字(chars[函数名结束位置]))
{
throw new 语法错误_Exception("函数定义错误： 缺少 函数名 。", chars, 函数名结束位置);
}
int 函数名开始位置的前一个位置 = Parser.向左寻找_不是_下划线字母数字_的字符(chars, span.iLeft, 函数名结束位置);
int 函数名开始位置;
if (函数名开始位置的前一个位置 == -1)
{
函数名开始位置 = span.iLeft;
}
else
{
函数名开始位置 = 函数名开始位置的前一个位置 + 1;
};
char c = chars[函数名开始位置];
string 函数名 = new string(chars, 函数名开始位置, 函数名结束位置 - 函数名开始位置 + 1);
if (!(c == '_' || StrUtil.IsLetter(c)))
{
throw new 语法错误_Exception("无效的 函数名 \"" + 函数名 + "\"，函数名 应由 下划线字母数字 组成且以 下划线或字母 开头 。", chars, 函数名开始位置);
}
if (Util.Check_是否关键字(函数名))
{
throw new 语法错误_Exception("无效的 函数名 \"" + 函数名 + "\"，函数名 不能和 关键字 相同 。", chars, 函数名开始位置);
}
//变量声明 返回类型;
//if (函数名开始位置 == span.iLeft)
//{
// return Parse(chars, -1, -1, span.iLeft, 函数名结束位置, 左小括号位置, 右小括号位置, 代码块.大括号块.iLeft, 代码块.大括号块.iRight);
//}
//c = chars[函数名开始位置 - 1];
//if (!StrUtil.IsOneOf(c, Parser._whiteSpaces和星号))
// throw new InnerCException("未结束的语句，可能缺少分号 \";\" 。", chars, 函数名开始位置 - 1);
int 报错位置;
类型 返回类型 = Parse_返回类型(chars, span.iLeft, 函数名开始位置 - 1, out 报错位置);
if (报错位置 != -1)
{
throw new 语法错误_Exception("未结束的语句，可能缺少分号 \";\" 。", chars, 报错位置);
}
作用域 形参列表 = Parse_形参列表(chars, 左小括号位置, 右小括号位置);
块作用域 函数体 = Parse_函数体(chars, 代码块.大括号块);
return(new 函数(返回类型, 函数名, 形参列表, 函数体, 函数名开始位置));
//int 空白和星号开始的位置的前一个位置 = StrUtil.FindBackwardUntilNot(chars, span.iLeft, 函数名开始位置 - 1, Parser._whiteSpaces和星号);
//int 空白和星号开始位置;
//if (空白和星号开始的位置的前一个位置 == -1)
//{
// K
//}
//args_beginIndex = i + 1;
//beginIndex = i - 1;
//StrSpan 函数名和返回值 = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);
//if (函数名和返回值.isEmpty)
// throw new InnerCException("函数定义错误： 缺少 函数名 。", chars, beginIndex - 1);
//StrSpan[] spans = Parser.从右向左寻找第一个空白字符以此Split将得到的两个字符串Trim返回(chars, 函数名和返回值.iLeft, 函数名和返回值.iRight);
//StrSpan 参数列表 = new StrSpan(args_beginIndex, args_endIndex);
//StrSpan 函数体 = StrUtil.Trim(chars, 大括号块.iLeft + 1, 大括号块.iRight - 1, Parser._whiteSpaces);
//return new 函数块(span, spans[0], spans[1], 参数列表, 函数体);
}