public static bool Check_是否_下划线字母数字(char c)
{
if (c == '_' || StrUtil.IsLetter(c) || StrUtil.IsNumber(c))
{
return(true);
}
return(false);
}
public static return_语句 Parse_return_语句(char[] chars, int beginIndex, int endIndex, out int 语句结束位置)
{
语句结束位置 = -1;
StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);
if (span.isEmpty)
{
return(null);
}
if (!Parser.开头一段_Equals(chars, span.iLeft, span.iRight, "return"))
{
return(null);
}
int return后的位置 = span.iLeft + 6;
if (return后的位置 > span.iRight)
{
throw new InnerCException("未结束的 return 语句 。", chars, span.iLeft);
}
char c = chars[return后的位置];
if (c == '_' || StrUtil.IsLetter(c) || StrUtil.IsNumber(c))
{
return(null);
}
语句结束位置 = Parser.Find_单引号对双引号对以外的内容(chars, return后的位置, span.iRight, ';');
if (语句结束位置 == -1)
{
throw new InnerCException("未结束的 return 语句，缺少分号 \";\" 。", chars, span.iLeft);
}
StrSpan span返回值 = StrUtil.Trim(chars, return后的位置, 语句结束位置 - 1, Parser._whiteSpaces);
表达式 返回值;
if (span返回值.isEmpty)
{
返回值 = null;
}
else
{
返回值 = 表达式_Parser.Parse(chars, span返回值.iLeft, span返回值.iRight);
}
return(new return_语句(返回值));
}
public static continue_语句 Parse_continue_语句(char[] chars, int beginIndex, int endIndex, out int 语句结束位置)
{
语句结束位置 = -1;
StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);
if (span.isEmpty)
{
return(null);
}
if (!Parser.开头一段_Equals(chars, span.iLeft, span.iRight, "continue"))
{
return(null);
}
int break后的位置 = span.iLeft + 5;
if (break后的位置 > span.iRight)
{
throw new InnerCException("未结束的 continue 语句 。", chars, span.iLeft);
}
char c = chars[break后的位置];
if (c == '_' || StrUtil.IsLetter(c) || StrUtil.IsNumber(c))
{
return(null);
}
int break后不是空白的位置 = StrUtil.FindForwardUntilNot(chars, break后的位置, span.iRight, Parser._whiteSpaces);
if (break后不是空白的位置 == -1)
{
throw new InnerCException("未结束的 continue 语句，缺少分号 \";\" 。", chars, span.iLeft);
}
c = chars[break后不是空白的位置];
if (c != ';')
{
throw new InnerCException("无效的 continue 语句，无效的字符 \"" + c + "\" 。", chars, break后不是空白的位置);
}
语句结束位置 = break后不是空白的位置;
return(new continue_语句());
}
public static bool Check_是否_下划线字母数字_且以_下划线字母_开头(char[] chars, int beginIndex, int endIndex)
{
char c = chars[beginIndex];
if (c != '_' && !StrUtil.IsLetter(c))
{
return(false);
}
for (int i = beginIndex + 1; i <= endIndex; i++)
{
c = chars[i];
if (c != '_' && !StrUtil.IsLetter(c) && !StrUtil.IsNumber(c))
{
return(false);
}
}
return(true);
}
public static bool Check_是否_下划线字母数字_且以_下划线字母_开头(string str)
{
char c = str[0];
if (c != '_' && !StrUtil.IsLetter(c))
{
return(false);
}
for (int i = 1; i < str.Length; i++)
{
c = str[i];
if (c != '_' && !StrUtil.IsLetter(c) && !StrUtil.IsNumber(c))
{
return(false);
}
}
return(true);
}
private static 类型 Parse_返回类型(char[] chars, int beginIndex, int endIndex, out int 报错位置)
{
报错位置 = -1;
类型 返回类型 = new 类型("void", 0, null, chars, endIndex);
//if (beginIndex > endIndex)
//{
// 报错位置 = -1;
// return 返回类型;
//}
StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);
if (span.isEmpty)
{
//报错位置 = -1;
return(返回类型);
}
char c = chars[endIndex];
if (!StrUtil.IsOneOf(c, Parser._whiteSpaces和星号))
{
报错位置 = endIndex;
return(返回类型);
}
int 空白和星号开始位置的前一个位置 = StrUtil.FindBackwardUntilNot(chars, span.iLeft, span.iRight, Parser._whiteSpaces和星号);
if (空白和星号开始位置的前一个位置 == -1)
{
报错位置 = span.iRight;
return(返回类型);
}
c = chars[空白和星号开始位置的前一个位置];
if (!Util.Check_是否_下划线字母数字(c))
{
报错位置 = span.iRight;
return(返回类型);
}
int 类型开始位置的前一个位置 = Parser.向左寻找_不是_下划线字母数字_的字符(chars, span.iLeft, 空白和星号开始位置的前一个位置);
int 类型开始位置;
if (类型开始位置的前一个位置 == -1)
{
类型开始位置 = span.iLeft;
}
else
{
类型开始位置 = 类型开始位置的前一个位置 + 1;
}
c = chars[类型开始位置];
if (!(c == '_' || StrUtil.IsLetter(c)))
{
报错位置 = span.iRight;
return(返回类型);
}
string type = new string(chars, 类型开始位置, 空白和星号开始位置的前一个位置 - 类型开始位置 + 1);
int 星号Count = 0;
for (int i = 空白和星号开始位置的前一个位置 + 1; i <= span.iRight; i++)
{
c = chars[i];
if (c == '*')
{
星号Count++;
}
}
返回类型 = new 类型(type, 星号Count, null, chars, 类型开始位置);
if (span.iLeft < 类型开始位置)
{
报错位置 = 类型开始位置 - 1;
}
return(返回类型);
}
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], 参数列表, 函数体);
}
public static 变量声明和初始化 Parse_变量声明(char[] chars, int beginIndex, int endIndex)
{
StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);
if (span.isEmpty)
{
return(null);
}
char c = chars[span.iLeft];
if (!(c == '_' || StrUtil.IsLetter(c)))
{
return(null);
}
int 类型结束的位置的下一个字符位置 = Parser.向右寻找_不是_下划线字母数字_的字符(chars, span.iLeft + 1, span.iRight);
if (类型结束的位置的下一个字符位置 == -1)
{
return(null);
}
c = chars[类型结束的位置的下一个字符位置];
if (!(StrUtil.IsOneOf(c, Parser._whiteSpaces)) || c == '*')
{
return(null);
}
int 类型后不是空白和星号的位置 = StrUtil.FindForwardUntilNot(chars, 类型结束的位置的下一个字符位置, span.iRight, Parser._whiteSpaces和星号);
if (类型后不是空白和星号的位置 == -1)
{
return(null);
}
c = chars[类型后不是空白和星号的位置];
if (!(c == '_' || StrUtil.IsLetter(c)))
{
return(null);
}
int 星号Count = 0;
for (int i = 类型结束的位置的下一个字符位置; i < 类型后不是空白和星号的位置; i++)
{
if (chars[i] == '*')
{
星号Count++;
}
}
表达式 表达式 = 表达式_Parser.Parse(chars, 类型后不是空白和星号的位置, span.iRight);
int 类型字符串长度 = 类型结束的位置的下一个字符位置 - span.iLeft;
变量声明和初始化 变量声明 = Parse_普通变量声明(chars, 表达式, span.iLeft, 类型字符串长度, 星号Count);
if (变量声明 != null)
{
return(变量声明);
}
变量声明 = Parse_数组变量声明(chars, 表达式, span.iLeft, 类型字符串长度, 星号Count);
if (变量声明 != null)
{
return(变量声明);
}
return(null);
}
