public override void Set_作用域(作用域 作用域)
{
base.Set_作用域(作用域);
作用域 小括号作用域 = new 作用域();
for (int i = 0; i < this.小括号表达式s.Length; i++)
{
表达式 express = this.小括号表达式s[i];
if (express == null)
{
continue;
}
变量声明和初始化 变量声明 = express as 变量声明和初始化;
if (变量声明 != null)
{
小括号作用域.Add_变量定义(变量声明, 变量声明.chars);
}
express.Set_作用域(小括号作用域);
}
小括号作用域.Set_作用域(作用域);
this.子句.Set_作用域(小括号作用域);
}
private static 变量声明和初始化语句 Parse_变量声明和初始化_语句(char[] chars, int beginIndex, int endIndex, out int 语句结束位置)
{
语句结束位置 = -1;
StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);
if (span.isEmpty)
{
return(null);
}
语句结束位置 = Parser.Find_单引号对双引号对以外的内容(chars, span.iLeft, span.iRight, ';');
if (语句结束位置 == -1)
{
return(null);
}
变量声明和初始化 变量声明 = Parse_变量声明(chars, span.iLeft, 语句结束位置 - 1);
if (变量声明 == null)
{
return(null);
}
return(new 变量声明和初始化语句(变量声明));
//变量 变量 = 表达式 as 变量;
//if (变量 != null)
//{
// return new 变量声明语句(new string(chars, beginIndex, 类型结束的位置的下一个字符位置 - beginIndex), 变量.name, 星号Count, null);
//}
//赋值 赋值 = 表达式 as 赋值;
//if (赋值 != null)
//{
// 变量 = 赋值.等号左边的表达式 as 变量;
// if (变量 != null)
// {
// 赋值语句 = new 赋值语句(赋值);
// return new 变量声明语句(new string(chars, beginIndex, 类型结束的位置的下一个字符位置 - beginIndex), 变量.name, 星号Count, null);
// }
// 数组元素 数组元素 = 赋值.等号左边的表达式 as 数组元素;
// if (数组元素 != null)
// {
// 变量 = 数组元素.左边的表达式 as 变量;
// if (变量 != null)
// 赋值语句 = new 赋值语句(new 赋值());
// return new 变量声明语句(new string(chars, beginIndex, 类型结束的位置的下一个字符位置 - beginIndex), 变量.name, 星号Count, null);
// }
//}
}
public void Add_变量定义(变量声明和初始化 变量声明, char[] chars)
{
if (this.dic变量声明.ContainsKey(变量声明.name))
{
throw new 语法错误_Exception("在当前作用域内已定义了名为 \"" + 变量声明.name + "\" 的变量 。", chars, 变量声明.变量名位置);
}
//throw new 语法错误_Exception("参数名 \"" + 变量声明.name + "\" 重复 。", chars, 变量声明.变量名位置);
变量声明.Set_作用域(this);
this.dic变量声明.Add(变量声明.name, 变量声明);
}
private static 表达式[] Parse_小括号(char[] chars, int 左小括号位置, int 右小括号位置)
{
//作用域 形参列表 = new 作用域();
表达式[] 小括号表达式s = new 表达式[3];
StrSpan span = StrUtil.Trim(chars, 左小括号位置 + 1, 右小括号位置 - 1, Parser._whiteSpaces);
if (span.isEmpty)
{
throw new 语法错误_Exception("for() 小括号内应是两个分号 。", chars, 左小括号位置);
}
//return exppressArr;
List <StrSpan> list = Parser.在_单引号双引号_以外_Split(chars, span.iLeft, span.iRight, ';');
if (list.Count != 3)
{
throw new 语法错误_Exception("for() 小括号内应是两个分号 。", chars, 左小括号位置);
}
StrSpan spanExpress;
for (int i = 0; i < list.Count; i++)
{
spanExpress = list[i];
变量声明和初始化 变量声明 = 语句_Parser.Parse_变量声明(chars, spanExpress.iLeft, spanExpress.iRight);
if (变量声明 != null)
{
小括号表达式s[i] = 变量声明;
continue;
}
表达式 表达式 = 表达式_Parser.Parse(chars, spanExpress.iLeft, spanExpress.iRight);
小括号表达式s[i] = 表达式;
}
return(小括号表达式s);
}
private static 字段声明 Parse_字段(char[] chars, StrSpan span)
{
if (span.isEmpty)
{
throw new InnerCException("缺少字段定义 。", chars, span.iLeft);
}
//span = StrUtil.Trim(chars, span.iLeft, span.iRight, Parser._whiteSpaces);
//if (span.isEmpty)
// throw new InnerCException("缺少字段定义 。", chars, span.iLeft);
变量声明和初始化 变量声明 = 语句_Parser.Parse_变量声明(chars, span.iLeft, span.iRight);
if (变量声明 == null)
{
throw new InnerCException("错误的字段定义 。", chars, span.iLeft);
}
return(变量声明.To_字段声明());
}
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 变量声明和初始化语句(变量声明和初始化 变量声明)
{
this.变量声明 = 变量声明;
}
public static 块作用域 Parse_块作用域(char[] chars, int beginIndex, int endIndex, ParseOptions option, out int j)
{
j = -1;
块作用域 块 = new 块作用域();
StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);
if (span.isEmpty)
{
return(块);
}
//int j;
//List<语句> list语句 = new List<语句>();
for (int i = span.iLeft; ; i = j + 1)
{
span = StrUtil.Trim(chars, i, span.iRight, Parser._whiteSpaces);
if (span.isEmpty)
{
break;
}
//if (Check_变量类型_KeyWord(chars, i, 代码段.iRight, "int"))
//{
// 语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, "int", out j, list变量声明);
//}
//else if (Check_变量类型_KeyWord(chars, i, 代码段.iRight, "float"))
//{
// 语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, "float", out j, list变量声明);
//}
//else if (Check_变量类型_KeyWord(chars, i, 代码段.iRight, "double"))
//{
// 语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, "double", out j, list变量声明);
//}
//else if (Check_变量类型_KeyWord(chars, i, 代码段.iRight, "char"))
//{
// 语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, "char", out j, list变量声明);
//}
//if (Check_if_while_KeyWord(chars, i, 代码段.iRight, "if"))
//{
// 语句 = Parse_if_语句(chars, i, 代码段.iRight, out j, list变量声明);
//}
//else if (Check_if_while_KeyWord(chars, i, 代码段.iRight, "while"))
//{
// 语句 = Parse_while_语句(chars, i, 代码段.iRight, out j, list变量声明);
//}
//else if (Check_return_KeyWord(chars, i, 代码段.iRight))
//{
// 语句 = Parse_return_语句(chars, i, 代码段.iRight, out j, list变量声明);
//}
//else if (Check_变量声明(chars, i, 代码段.iRight, out 变量类型))
//{
// 语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, 变量类型, out j, list变量声明);
//}
//else
//{
// 语句 = Parse_表达式_语句(chars, i, 代码段.iRight, out j, list变量声明);
//}
if_语句 if_语句 = if_语句_Parser.Parse(chars, span.iLeft, span.iRight, out j);
if (if_语句 != null)
{
if_语句.Set_作用域(块);
块.list语句.Add(if_语句);
continue;
}
while_语句 while_语句 = while_语句_Parser.Parse(chars, span.iLeft, span.iRight, out j);
if (while_语句 != null)
{
while_语句.Set_作用域(块);
块.list语句.Add(while_语句);
continue;
}
break_语句 break_语句 = Parse_break_语句(chars, span.iLeft, span.iRight, out j);
if (break_语句 != null)
{
break_语句.Set_作用域(块);
块.list语句.Add(break_语句);
continue;
}
return_语句 return_语句 = Parse_return_语句(chars, span.iLeft, span.iRight, out j);
if (return_语句 != null)
{
return_语句.Set_作用域(块);
块.list语句.Add(return_语句);
continue;
}
变量声明和初始化语句 变量声明语句 = Parse_变量声明和初始化_语句(chars, span.iLeft, span.iRight, out j);
if (变量声明语句 != null)
{
变量声明和初始化 变量声明 = 变量声明语句.变量声明;
if (块.dic变量声明.ContainsKey(变量声明.name))
{
throw new InnerCException("在当前作用域范围内已定义了名为 \"" + 变量声明.name + "\" 的变量 。", chars, 变量声明.变量位置_iLeft);
}
变量声明语句.Set_作用域(块);
块.dic变量声明.Add(变量声明.name, 变量声明);
块.list语句.Add(变量声明语句);
continue;
}
表达式语句 表达式语句 = Parse_表达式语句(chars, span.iLeft, span.iRight, out j);
if (表达式语句 != null)
{
表达式语句.Set_作用域(块);
块.list语句.Add(表达式语句);
}
if (option == ParseOptions.Parse_第一个语句)
{
break;
}
}
return(块);
}
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);
}