mirror of
https://gitee.com/langsisi_admin/serein-flow
synced 2026-03-03 00:00:49 +08:00
1273 lines
53 KiB
C#
1273 lines
53 KiB
C#
using Newtonsoft.Json.Linq;
|
||
using Serein.Library;
|
||
using Serein.Library.Utils;
|
||
using Serein.Script.Node;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Linq.Expressions;
|
||
using System.Reflection;
|
||
using System.Text;
|
||
using System.Xml.Linq;
|
||
|
||
namespace Serein.Script
|
||
{
|
||
|
||
/// <summary>
|
||
/// SereinScriptParser 用于解析 Serein 脚本语言的语法。
|
||
/// </summary>
|
||
public ref struct SereinScriptParser
|
||
{
|
||
private SereinScriptLexer _lexer;
|
||
private Token _currentToken;
|
||
|
||
|
||
public SereinScriptParser(string script)
|
||
{
|
||
_lexer = new SereinScriptLexer(script); // 语法分析
|
||
_currentToken = _lexer.NextToken();
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 解析脚本并返回 AST（抽象语法树）根节点。
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public ProgramNode Parse()
|
||
{
|
||
|
||
return Program();
|
||
}
|
||
|
||
|
||
|
||
private List<ASTNode> Statements { get; } = new List<ASTNode>();
|
||
|
||
/// <summary>
|
||
/// 解析整个程序，直到遇到文件结尾（EOF）为止。
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private ProgramNode Program()
|
||
{
|
||
Statements.Clear();
|
||
while (_currentToken.Type != TokenType.EOF)
|
||
{
|
||
|
||
var astNode = Statement(); // 解析单个语句
|
||
if (astNode == null)
|
||
{
|
||
continue;
|
||
}
|
||
Statements.Add(astNode); // 将解析得到的 AST 节点添加到语句列表中
|
||
}
|
||
var programNode = new ProgramNode(Statements);
|
||
programNode.SetTokenInfo(_currentToken); // 程序节点，包含所有解析的语句列表
|
||
|
||
return programNode;
|
||
|
||
/*if (astNode is ClassTypeDefinitionNode)
|
||
{
|
||
statements = [astNode, ..statements]; // 类型定义置顶
|
||
}
|
||
else
|
||
{
|
||
statements.Add(astNode);
|
||
}*/
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析单个语句。
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode Statement()
|
||
{
|
||
|
||
// 处理其他语句（如表达式语句等）
|
||
while (_currentToken.Type == TokenType.Semicolon)
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
}
|
||
if(_currentToken.Type == TokenType.EOF)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
|
||
if (_currentToken.Type == TokenType.Keyword && _currentToken.Value == "let")
|
||
{
|
||
// 处理 let 变量赋值语句
|
||
return ParseLetAssignment();
|
||
}
|
||
if (_currentToken.Type == TokenType.Keyword && _currentToken.Value == "class")
|
||
{
|
||
|
||
// 加载类定义
|
||
return ParseClassDefinition(); // 加载类，如果已经加载过，则忽略
|
||
}
|
||
if (_currentToken.Type == TokenType.Keyword && _currentToken.Value == "new")
|
||
{
|
||
var _peekToken = _lexer.PeekToken();
|
||
if (_peekToken.Type == TokenType.Keyword && _peekToken.Value == "class")
|
||
{
|
||
// 重新加载类定义
|
||
return ParseClassDefinition(); // 重新加载类
|
||
}
|
||
}
|
||
|
||
if (_currentToken.Type == TokenType.Keyword && _currentToken.Value == "if")
|
||
{
|
||
// 处理 if 语句
|
||
return ParseIf();
|
||
}
|
||
if (_currentToken.Type == TokenType.Keyword && _currentToken.Value == "while")
|
||
{
|
||
// 处理 while 循环语句
|
||
return ParseWhile();
|
||
}
|
||
if (_currentToken.Type == TokenType.Keyword && _currentToken.Value == "return")
|
||
{
|
||
// 处理 return 语句
|
||
return ParseReturn();
|
||
}
|
||
if (_currentToken.Type == TokenType.Identifier)
|
||
{
|
||
// 处理标识符，可能是函数调用、变量赋值或对象成员访问等行为
|
||
return ParseIdentifier();
|
||
}
|
||
if (_currentToken.Type == TokenType.Null)
|
||
{
|
||
// 处理 null 语句
|
||
return BooleanExpression();
|
||
return Expression();
|
||
}
|
||
|
||
/*if (_currentToken.Type == TokenType.Semicolon)
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
return null; // 表示空语句
|
||
}*/
|
||
|
||
|
||
|
||
throw new Exception("Unexpected statement: " + _currentToken.Value.ToString());
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 从标识符解析方法调用、变量赋值、获取对象成员行为。
|
||
/// （非符号、关键字）
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private ASTNode ParseIdentifier()
|
||
{
|
||
/*
|
||
localFunc();
|
||
obj.Func();
|
||
obj.Value = ...;
|
||
value = ...;
|
||
*/
|
||
var backupToken = _currentToken;
|
||
var tokenCount = 1;
|
||
var int_type = 0;
|
||
while (true)
|
||
{
|
||
var tempToken = _lexer.PeekToken(tokenCount++);
|
||
if (tempToken.Type == TokenType.Operator && tempToken.Value == "=")
|
||
{
|
||
var tempToken2 = _lexer.PeekToken(tokenCount);
|
||
if (tempToken2.Type == TokenType.SquareBracketsRight)
|
||
{
|
||
int_type = 2; // 变量数组赋值
|
||
break;
|
||
}
|
||
else // if (tempToken2.Type == TokenType.SquareBracketsRight)
|
||
{
|
||
int_type = 1; // 变量赋值
|
||
break;
|
||
}
|
||
}
|
||
if (tempToken.Type == TokenType.Semicolon)
|
||
{
|
||
var tempToken2 = _lexer.PeekToken(tokenCount);
|
||
if(tempToken2.Type == TokenType.ParenthesisRight)
|
||
{
|
||
int_type = 3; // 方法调用
|
||
break;
|
||
}
|
||
}
|
||
if(tempToken.Type == TokenType.ParenthesisLeft) // 本地函数调用
|
||
{
|
||
int_type = 4; // 本地方法调用
|
||
break;
|
||
}
|
||
|
||
}
|
||
if(int_type == 1) // 赋值 MemberAssignmentNode
|
||
{
|
||
var objectName = _currentToken.Value;
|
||
var objectNode = new IdentifierNode(objectName).SetTokenInfo(_currentToken); // 首先定义对象变量节点
|
||
var peekToken = _lexer.PeekToken();
|
||
if(peekToken.Type == TokenType.Operator && peekToken.Value == "=")
|
||
{
|
||
// 变量赋值
|
||
_currentToken = _lexer.NextToken(); // 消耗 变量名
|
||
_currentToken = _lexer.NextToken(); // 消耗 “=”
|
||
|
||
var valueNode = BooleanExpression();
|
||
var assignmentNode = new AssignmentNode(objectNode, valueNode).SetTokenInfo(_currentToken);
|
||
return assignmentNode;
|
||
}
|
||
else
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗对象名称
|
||
// 对象成员赋值
|
||
List<ASTNode> nodes = new List<ASTNode>(); // 表达对象成员路径的节点
|
||
while (true)
|
||
{
|
||
if (_currentToken.Type == TokenType.Dot)
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗 "." 获取下一个成员
|
||
if (_currentToken.Type == TokenType.Identifier)
|
||
{
|
||
var temp2token = _lexer.PeekToken();
|
||
var sourceNode = nodes.Count == 0 ? objectNode : nodes[^1];
|
||
if (temp2token.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 解析方法调用 obj.func()
|
||
ASTNode functionNode = ParseMemberFunctionCall(sourceNode).SetTokenInfo(_currentToken);
|
||
nodes.Add(functionNode);
|
||
}
|
||
else if (temp2token.Type == TokenType.SquareBracketsLeft)
|
||
{
|
||
// 成员数组 obj.dict[key] / obj.array[index]
|
||
if (_currentToken.Type == TokenType.Identifier)
|
||
{
|
||
var memberAccessNode = new MemberAccessNode(sourceNode, _currentToken.Value).SetTokenInfo(_currentToken);
|
||
sourceNode = memberAccessNode;
|
||
}
|
||
var coolectionNode = ParseCollectionIndex(sourceNode).SetTokenInfo(_currentToken);
|
||
nodes.Add(coolectionNode);
|
||
}
|
||
else if (temp2token.Type is TokenType.Dot /* or TokenType.ParenthesisRight*/)
|
||
{
|
||
// 成员获取 obj.value
|
||
var memberAccessNode = new MemberAccessNode(sourceNode, _currentToken.Value).SetTokenInfo(_currentToken);
|
||
nodes.Add(memberAccessNode);
|
||
}
|
||
else if (temp2token.Type == TokenType.Operator && temp2token.Value == "=")
|
||
{
|
||
// 左值结束， 成员获取 obj.value
|
||
/* var memberAccessNode = new MemberAccessNode(sourceNode, _currentToken.Value).SetTokenInfo(_currentToken);
|
||
nodes.Add(memberAccessNode);*/
|
||
var memberName = _currentToken.Value; // 成员名称
|
||
_currentToken = _lexer.NextToken(); // 消耗 成员 token
|
||
_currentToken = _lexer.NextToken(); // 消耗“=” 等号
|
||
var rightNode = BooleanExpression(); // 判断token
|
||
MemberAssignmentNode assignmentNode = new MemberAssignmentNode(sourceNode, memberName, rightNode);
|
||
assignmentNode.SetTokenInfo(_currentToken);
|
||
|
||
return assignmentNode; // 返回节点
|
||
break;
|
||
}
|
||
//_lexer.SetToken(peekToken); // 重置lexer
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
}
|
||
/*if (_currentToken.Type == TokenType.Operator && _currentToken.Value == "=")
|
||
{
|
||
// 等号意味着左值语句结束
|
||
break;
|
||
}*/
|
||
}
|
||
|
||
/* var leftValueNodes = nodes;
|
||
List<ASTNode> rightValueNode = new List<ASTNode>(); // 表达对象成员路径的节点*/
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
}
|
||
else if (int_type == 2) // 方法调用
|
||
{
|
||
var taretNode = "";
|
||
}
|
||
else if (int_type == 3) // 方法调用
|
||
{
|
||
var taretNode = "";
|
||
}
|
||
else if (int_type == 4) // 方法调用
|
||
{
|
||
// 可能是挂载函数调用
|
||
var functionCallNode = ParseFunctionCall();
|
||
return functionCallNode;
|
||
}
|
||
else
|
||
{
|
||
|
||
}
|
||
|
||
return null;
|
||
#region MyRegion
|
||
/*return null;
|
||
var _identifierPeekToken = _lexer.PeekToken();
|
||
if (_identifierPeekToken.Type == TokenType.Operator && _identifierPeekToken.Value == "=")
|
||
{
|
||
// 如果是操作符 = ，则是直接赋值变量
|
||
var leftValueNode = new IdentifierNode(_currentToken.Value).SetTokenInfo(_currentToken);
|
||
var rightValueNode = BooleanExpression();
|
||
return new AssignmentNode(leftValueNode, rightValueNode).SetTokenInfo(_currentToken);
|
||
|
||
//return new IdentifierNode(_currentToken.Value).SetTokenInfo(_currentToken); // 获取变量
|
||
}
|
||
if (_identifierPeekToken.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 可能是挂载函数调用
|
||
var functionCallNode = ParseFunctionCall();
|
||
return functionCallNode;
|
||
}
|
||
var objToken = _currentToken; // 对象Token
|
||
ASTNode? objectNode = new IdentifierNode(objToken.Value).SetTokenInfo(objToken); // 对象节点
|
||
var identifier = _currentToken.Value; // 标识符字面量
|
||
List<ASTNode> nodes = new List<ASTNode>();
|
||
while (true)
|
||
{
|
||
if (_currentToken.Type == TokenType.Dot)
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
if (_currentToken.Type == TokenType.Identifier)
|
||
{
|
||
var temp2token = _lexer.PeekToken();
|
||
var sourceNode = (nodes.Count == 0 ? objectNode : nodes[^1]);
|
||
if(temp2token.Type == TokenType.Operator && temp2token.Value == "=")
|
||
{
|
||
// 成员获取 obj.value =
|
||
var memberAccessNode = new MemberAccessNode(sourceNode, _currentToken.Value).SetTokenInfo(_currentToken);
|
||
nodes.Add(memberAccessNode);
|
||
//break;
|
||
// 赋值行为
|
||
*//*var assignmentNode = ParseAssignment();
|
||
nodes.Add(assignmentNode);*//*
|
||
}
|
||
else if (temp2token.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 解析方法调用 obj.func()
|
||
ASTNode functionNode = ParseMemberFunctionCall(sourceNode).SetTokenInfo(_currentToken);
|
||
nodes.Add(functionNode);
|
||
}
|
||
else if (temp2token.Type == TokenType.SquareBracketsLeft)
|
||
{
|
||
// 成员数组 obj.dict[key] / obj.array[index]
|
||
if (_currentToken.Type == TokenType.Identifier)
|
||
{
|
||
var memberAccessNode = new MemberAccessNode(sourceNode, _currentToken.Value).SetTokenInfo(_currentToken);
|
||
sourceNode = memberAccessNode;
|
||
}
|
||
var coolectionNode = ParseCollectionIndex(sourceNode).SetTokenInfo(_currentToken);
|
||
nodes.Add(coolectionNode);
|
||
}
|
||
else if (temp2token.Type is TokenType.Dot or TokenType.Semicolon or TokenType.ParenthesisRight )
|
||
{
|
||
// 成员获取 obj.value
|
||
var memberAccessNode = new MemberAccessNode(sourceNode, _currentToken.Value).SetTokenInfo(_currentToken);
|
||
nodes.Add(memberAccessNode);
|
||
}
|
||
//_lexer.SetToken(peekToken); // 重置lexer
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
}
|
||
if (nodes.Count > 0 && _currentToken.Type == TokenType.Operator && _currentToken.Value == "=")
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗操作符
|
||
// 分号意味着语句结束
|
||
var rightValueNode = BooleanExpression();
|
||
if (nodes.Count == 1)
|
||
{
|
||
//_currentToken = _lexer.NextToken(); // 右值
|
||
var assignmentNode = new AssignmentNode(nodes[0], rightValueNode);
|
||
//var node = nodes[^1];
|
||
return assignmentNode;
|
||
}
|
||
else
|
||
{
|
||
var objNode = new ObjectMemberExpressionNode(objectNode, nodes).SetTokenInfo(objToken);
|
||
var assignmentNode = new AssignmentNode(objNode, rightValueNode);
|
||
return objNode;
|
||
}
|
||
//AssignmentNode assignmentNode = new AssignmentNode(rightValueNode);
|
||
break;
|
||
}
|
||
if (_currentToken.Type is TokenType.Semicolon)
|
||
{
|
||
// 分号意味着语句结束
|
||
break;
|
||
}
|
||
}
|
||
if (nodes.Count == 0)
|
||
{
|
||
return objectNode;
|
||
}
|
||
if (nodes.Count == 1)
|
||
{
|
||
var t = new AssignmentNode(objectNode, nodes[^1]);
|
||
var node = nodes[^1];
|
||
return node;
|
||
}
|
||
else
|
||
{
|
||
var objNode = new ObjectMemberExpressionNode(objectNode, nodes).SetTokenInfo(objToken);
|
||
return objNode;
|
||
}*/
|
||
#endregion
|
||
|
||
// 检查标识符后是否跟有左圆括号
|
||
var _tempToken = _lexer.PeekToken();
|
||
if (_tempToken.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 解析函数调用
|
||
return ParseFunctionCall();
|
||
}
|
||
else if (_tempToken.Type == TokenType.Dot)
|
||
{
|
||
// 对象成员的获取
|
||
|
||
return ParseMemberAccessOrAssignment();
|
||
}
|
||
else if (_tempToken.Type == TokenType.SquareBracketsLeft)
|
||
{
|
||
// 数组 index; 字典 key obj.Member[xxx];
|
||
return ParseCollectionIndex();
|
||
|
||
}
|
||
else
|
||
{
|
||
// 不是函数调用，是变量赋值或其他
|
||
return ParseAssignment();
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 解析赋值行为
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode ParseAssignment()
|
||
{
|
||
string variableName = _currentToken.Value.ToString();
|
||
|
||
var _peekToken = _lexer.PeekToken();
|
||
if (_peekToken.Type == TokenType.ParenthesisRight)
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗标识符
|
||
|
||
return new IdentifierNode(variableName).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
if(_peekToken.Type == TokenType.Operator && _peekToken.Value == "=")
|
||
{
|
||
// 赋值行为
|
||
_currentToken = _lexer.NextToken(); // 消耗标识符
|
||
_currentToken = _lexer.NextToken(); // 消耗 "="
|
||
var _tempToken = _lexer.PeekToken();
|
||
ASTNode valueNode;
|
||
|
||
if(_tempToken.Type == TokenType.Operator && _tempToken.Value != "=")
|
||
{
|
||
//_currentToken = _lexer.NextToken(); // 消耗操作符
|
||
//_currentToken = _lexer.NextToken(); // 消耗操作符
|
||
valueNode = BooleanExpression();
|
||
//valueNode = Expression();
|
||
}
|
||
else if (_tempToken.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 解析赋值右边的表达式
|
||
// 是函数调用，解析函数调用
|
||
valueNode = ParseFunctionCall();
|
||
}
|
||
else
|
||
{
|
||
// 解析赋值右边的字面量表达式
|
||
valueNode = BooleanExpression();
|
||
//valueNode = Expression();
|
||
}
|
||
var variableNode = new IdentifierNode(variableName).SetTokenInfo(_currentToken);
|
||
return new AssignmentNode(variableNode, valueNode).SetTokenInfo(_currentToken);
|
||
}
|
||
if (_peekToken.Type == TokenType.Dot)
|
||
{
|
||
// 可能是方法调用
|
||
return ParseMemberAccessOrAssignment();
|
||
}
|
||
|
||
if(_peekToken.Type == TokenType.Operator)
|
||
{
|
||
return new IdentifierNode(variableName).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
|
||
throw new Exception($"Expected '{_currentToken.Value}' after variable name");
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析 let 变量赋值行为
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode ParseLetAssignment()
|
||
{
|
||
|
||
_currentToken = _lexer.NextToken(); // Consume "let"
|
||
string variableName = _currentToken.Value.ToString(); // 变量名称
|
||
_currentToken = _lexer.NextToken(); // Consume identifier
|
||
ASTNode value;
|
||
AssignmentNode assignmentNode;
|
||
if (_currentToken.Type == TokenType.Semicolon)
|
||
{
|
||
// 定义一个变量，初始值为 null
|
||
value = new NullNode();
|
||
var variableNode = new IdentifierNode(variableName).SetTokenInfo(_currentToken);
|
||
assignmentNode = new AssignmentNode(variableNode, value); // 生成node
|
||
assignmentNode.SetTokenInfo(_currentToken); // 设置token信息
|
||
}
|
||
else
|
||
{
|
||
// 如果定义了变量，后面紧跟着操作符，且操作符不是“=”话视为异常
|
||
// let value = obj;
|
||
if (_currentToken.Type != TokenType.Operator || _currentToken.Value != "=")
|
||
throw new Exception("Expected '=' after variable name");
|
||
_currentToken = _lexer.NextToken(); // 消耗操作符（“=”）
|
||
var nodeToken = _currentToken;
|
||
value = BooleanExpression(); // 解析获取赋值表达式
|
||
//value = Expression(); // 解析获取赋值表达式
|
||
var variableNode = new IdentifierNode(variableName).SetTokenInfo(_currentToken);
|
||
assignmentNode = new AssignmentNode(variableNode, value); // 生成node
|
||
assignmentNode.SetTokenInfo(nodeToken); // 设置token信息
|
||
_currentToken = _lexer.NextToken(); // 消耗分号
|
||
}
|
||
return assignmentNode;
|
||
|
||
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析类定义
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode ParseClassDefinition()
|
||
{
|
||
var sb = new StringBuilder(); // 收集代码信息
|
||
/*
|
||
* 有两种定义类型的方式：
|
||
* 1. class MyClass{}
|
||
* 2. new class MyClass{}
|
||
* 解析执行时，第二种方式定义的类，会顶掉其他地方创建的“MyClass”同名类型；
|
||
*/
|
||
var coreStartRangeIndex = _lexer.GetIndex() - "class".Length; // 从“class”开始锚定代码范围
|
||
bool isOverlay = false; // 指示是否覆盖缓存中创建过的同名其它类型
|
||
|
||
if (_currentToken.Value == "new")
|
||
{
|
||
isOverlay = true; // 重新加载类
|
||
_currentToken = _lexer.NextToken(); // 消耗 new 关键字
|
||
}
|
||
_currentToken = _lexer.NextToken(); // 消耗 class 关键字
|
||
var className = _currentToken.Value.ToString(); // 获取定义的类名
|
||
_currentToken = _lexer.NextToken(); // 消耗类名
|
||
if (_currentToken.Type != TokenType.BraceLeft || _currentToken.Value != "{")
|
||
throw new Exception("Expected '{' after class definition");
|
||
var classFields = new Dictionary<string, Type>();
|
||
_currentToken = _lexer.NextToken(); // 消耗括号
|
||
|
||
while (_currentToken.Type != TokenType.BraceRight)
|
||
{
|
||
// 获取类字段定义
|
||
var fieldTypeName = _currentToken.Value.ToString();
|
||
var dynamicType = DynamicObjectHelper.GetCacheType(fieldTypeName);
|
||
|
||
var fieldType = dynamicType ?? _currentToken.Value.ToString().ToTypeOfString(); // 获取字段的类型
|
||
_currentToken = _lexer.NextToken(); // 消耗类型
|
||
var fieldName = _currentToken.Value.ToString(); // 获取定义的类名
|
||
_currentToken = _lexer.NextToken(); // 消耗字段名称
|
||
classFields.Add(fieldName,fieldType); // 添加字段
|
||
if (_currentToken.Type == TokenType.Semicolon
|
||
&& _lexer.PeekToken().Type == TokenType.BraceRight)
|
||
{
|
||
// 如果遇到分号、大括号，退出字段定义。
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
}
|
||
|
||
}
|
||
_currentToken = _lexer.NextToken(); // 消耗类型定义 } 括号
|
||
var typeDefinitionCode = _lexer.GetCoreContent(coreStartRangeIndex); // 收集类型定义的代码。
|
||
|
||
DynamicObjectHelper.CreateTypeWithProperties(classFields, className, isOverlay); // 解析时缓存类型
|
||
var node = new ClassTypeDefinitionNode(classFields, className, isOverlay);
|
||
_currentToken.Code = typeDefinitionCode;
|
||
node.SetTokenInfo(_currentToken);
|
||
// _currentToken = _lexer.NextToken();
|
||
_currentToken = _lexer.NextToken();
|
||
return node;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析对象实例化行为
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
public ASTNode ParseObjectInstantiation()
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗 new 关键字
|
||
string typeName = _currentToken.Value.ToString(); // 获取类型名称
|
||
_currentToken = _lexer.NextToken();
|
||
if (_currentToken.Type != TokenType.ParenthesisLeft)
|
||
throw new Exception("Expected '(' after function name");
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗 "("
|
||
|
||
var arguments = new List<ASTNode>();
|
||
while (_currentToken.Type != TokenType.ParenthesisRight)
|
||
{
|
||
//arguments.Add(Expression()); // 获取参数表达式
|
||
arguments.Add(BooleanExpression()); // 获取参数表达式
|
||
if (_currentToken.Type == TokenType.Comma)
|
||
{
|
||
_currentToken = _lexer.NextToken(); // consume ","
|
||
}
|
||
}
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗 ")"
|
||
return new ObjectInstantiationNode(typeName, arguments).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析集合索引行为（数组或字典）
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
public ASTNode ParseCollectionIndex()
|
||
{
|
||
var identifierNode = new IdentifierNode(_currentToken.Value.ToString()).SetTokenInfo(_currentToken);
|
||
|
||
string collectionName = _currentToken.Value.ToString();
|
||
//_lexer.NextToken(); // consume "["
|
||
_currentToken = _lexer.NextToken(); // 消耗数组名称 identifier
|
||
// ParenthesisLeft
|
||
if (_currentToken.Type != TokenType.SquareBracketsLeft)
|
||
throw new Exception("Expected '[' after function name");
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗 "["
|
||
|
||
//ASTNode indexValue = Expression(); // 获取表达数组下标的节点
|
||
ASTNode indexValue = BooleanExpression(); // 获取表达数组下标的节点
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗 "]"
|
||
return new CollectionIndexNode(identifierNode, indexValue).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指定对象解析集合索引行为（数组或字典）
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
public ASTNode ParseCollectionIndex(ASTNode ObjectNode)
|
||
{
|
||
string collectionName = _currentToken.Value.ToString();
|
||
_currentToken = _lexer.NextToken(); // 消耗数组名称 identifier
|
||
// ParenthesisLeft
|
||
if (_currentToken.Type != TokenType.SquareBracketsLeft)
|
||
throw new Exception("Expected '[' after function name");
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗 "["
|
||
|
||
//ASTNode indexValue = Expression(); // 获取表达数组下标的节点
|
||
ASTNode indexValue = BooleanExpression(); // 获取表达数组下标的节点
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗 "]"
|
||
return new CollectionIndexNode(ObjectNode, indexValue).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取对象成员
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode ParseMemberAccessOrAssignment()
|
||
{
|
||
var identifierNode = new IdentifierNode(_currentToken.Value).SetTokenInfo(_currentToken);
|
||
_currentToken = _lexer.NextToken(); // 消耗当前标识符
|
||
|
||
|
||
// 处理成员访问：identifier.member
|
||
if (_currentToken.Type == TokenType.Dot)
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗 "."
|
||
if (_currentToken.Type != TokenType.Identifier)
|
||
{
|
||
throw new Exception("Expected member name after dot.");
|
||
}
|
||
|
||
var memberName = _currentToken.Value;
|
||
//_currentToken = _lexer.NextToken(); // 消耗成员名
|
||
|
||
var _peekToken = _lexer.PeekToken();
|
||
if (_peekToken.Type == TokenType.Operator && _peekToken.Value == "=")
|
||
{
|
||
// 成员赋值 obj.Member = xxx;
|
||
_currentToken = _lexer.NextToken(); // 消耗 "="
|
||
_currentToken = _lexer.NextToken(); // 消耗 "="
|
||
//var valueNode = Expression(); // 解析右值
|
||
var valueNode = BooleanExpression(); // 解析右值
|
||
_currentToken = _lexer.NextToken(); // 消耗 变量
|
||
//_currentToken = _lexer.NextToken(); // 消耗 ;
|
||
return new MemberAssignmentNode(identifierNode, memberName, valueNode).SetTokenInfo(_peekToken);
|
||
}
|
||
else
|
||
{
|
||
|
||
if(_peekToken.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 成员方法调用 obj.Member(xxx);
|
||
return ParseMemberFunctionCall(identifierNode);
|
||
}
|
||
else if (_peekToken.Type == TokenType.SquareBracketsLeft)
|
||
{
|
||
// 数组 index; 字典 key obj.Member[xxx];
|
||
return ParseCollectionIndex();
|
||
}
|
||
else
|
||
{
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗 成员名称
|
||
// 成员获取
|
||
return new MemberAccessNode(identifierNode, memberName).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
return identifierNode;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 解析成员函数调用行为
|
||
/// </summary>
|
||
/// <param name="targetNode"></param>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode ParseMemberFunctionCall(ASTNode targetNode)
|
||
{
|
||
string functionName = _currentToken.Value.ToString(); // 函数名称
|
||
_currentToken = _lexer.NextToken(); // 消耗函数名称
|
||
|
||
if (_currentToken.Type != TokenType.ParenthesisLeft)
|
||
throw new Exception("Expected '(' after function name");
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗 "("
|
||
|
||
var arguments = new List<ASTNode>();
|
||
while (_currentToken.Type != TokenType.ParenthesisRight)
|
||
{
|
||
// 获取参数表达式
|
||
//var arg = Expression();
|
||
var arg = BooleanExpression();
|
||
_currentToken = _lexer.NextToken(); // 消耗参数 arg
|
||
arguments.Add(arg); // 添加到参数列表
|
||
if (_currentToken.Type == TokenType.Comma)
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗参数分隔符 ","
|
||
}
|
||
if (_currentToken.Type == TokenType.Semicolon)
|
||
{
|
||
break; // 消耗 ";"
|
||
}
|
||
}
|
||
|
||
//_currentToken = _lexer.NextToken(); // consume ")"
|
||
|
||
return new MemberFunctionCallNode(targetNode, functionName, arguments).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 解析函数调用行为
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode ParseFunctionCall()
|
||
{
|
||
string functionName = _currentToken.Value.ToString();
|
||
_currentToken = _lexer.NextToken(); // consume identifier
|
||
|
||
if (_currentToken.Type != TokenType.ParenthesisLeft)
|
||
throw new Exception("Expected '(' after function name");
|
||
|
||
_currentToken = _lexer.NextToken(); // consume "("
|
||
|
||
bool isBreak = false;
|
||
var arguments = new List<ASTNode>();
|
||
// 获取参数
|
||
while (true)// _currentToken.Type != TokenType.ParenthesisRight
|
||
{
|
||
//var arg = Expression(); // 获取参数表达式
|
||
var arg = BooleanExpression(); // 获取参数表达式
|
||
arguments.Add(arg);
|
||
if (_currentToken.Type == TokenType.Comma)
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗参数分隔符 ","
|
||
}
|
||
if (_currentToken.Type == TokenType.ParenthesisRight )
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗方法结束括号 "）"
|
||
}
|
||
if (_currentToken.Type == TokenType.Semicolon )
|
||
{
|
||
//isBreak = true;
|
||
break; // consume ";"
|
||
}
|
||
/*if (_currentToken.Type == TokenType.Semicolon) // 提前结束
|
||
{
|
||
arguments.Add(arg);
|
||
isBreak = true;
|
||
break; // consume ";"
|
||
}*/
|
||
//_currentToken = _lexer.NextToken(); // consume arg
|
||
}
|
||
//if(!isBreak)
|
||
// _currentToken = _lexer.NextToken(); // consume ")"
|
||
|
||
|
||
//var node = Statements[^1];
|
||
//if (node is MemberAccessNode memberAccessNode)
|
||
//{
|
||
// // 上一个是对象
|
||
// return new MemberFunctionCallNode(memberAccessNode, functionName, arguments).SetTokenInfo(_currentToken);
|
||
//}
|
||
//if (node is IdentifierNode identifierNode)
|
||
//{
|
||
// return new MemberFunctionCallNode(identifierNode, functionName, arguments).SetTokenInfo(_currentToken);
|
||
//}
|
||
|
||
// 从挂载的函数表寻找对应的函数，尝试调用
|
||
return new FunctionCallNode(functionName, arguments).SetTokenInfo(_currentToken);
|
||
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析 return 语句。
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public ASTNode ParseReturn()
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
if(_currentToken.Type == TokenType.Semicolon)
|
||
{
|
||
return new ReturnNode().SetTokenInfo(_currentToken); // 返回空的 ReturnNode
|
||
}
|
||
var resultValue = BooleanExpression(); // 获取返回值表达式
|
||
//var resultValue = Expression(); // 获取返回值表达式
|
||
_currentToken = _lexer.NextToken();
|
||
return new ReturnNode(resultValue).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 解析 if 语句。
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode ParseIf()
|
||
{
|
||
_currentToken = _lexer.NextToken(); // Consume "if"
|
||
_currentToken = _lexer.NextToken(); // Consume "("
|
||
ASTNode condition = BooleanExpression();
|
||
//ASTNode condition = Expression();
|
||
_currentToken = _lexer.NextToken(); // Consume ")"
|
||
|
||
// 确保遇到左大括号 { 后进入代码块解析
|
||
if (_currentToken.Type != TokenType.BraceLeft)
|
||
{
|
||
throw new Exception("Expected '{' after if condition");
|
||
}
|
||
_currentToken = _lexer.NextToken(); // Consume "{"
|
||
|
||
// 解析大括号中的语句
|
||
List<ASTNode> trueBranch = new List<ASTNode>();
|
||
List<ASTNode> falseBranch = new List<ASTNode>();
|
||
while (_currentToken.Type != TokenType.BraceRight && _currentToken.Type != TokenType.EOF)
|
||
{
|
||
var astNode = Statement(); // 解析 if 分支中的语句
|
||
while (_currentToken.Type == TokenType.Semicolon)
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
}
|
||
if (astNode != null)
|
||
{
|
||
trueBranch.Add(astNode); // 将 if 分支的语句添加到 trueBranch 中
|
||
}
|
||
}
|
||
// 确保匹配右大括号 }
|
||
if (_currentToken.Type != TokenType.BraceRight)
|
||
{
|
||
throw new Exception("Expected '}' after if block");
|
||
}
|
||
_currentToken = _lexer.NextToken(); // Consume "}"
|
||
if (_currentToken.Type == TokenType.Keyword && _currentToken.Value == "else")
|
||
{
|
||
_currentToken = _lexer.NextToken(); // Consume "{"
|
||
_currentToken = _lexer.NextToken(); // Consume "{"
|
||
while (_currentToken.Type != TokenType.BraceRight && _currentToken.Type != TokenType.EOF)
|
||
{
|
||
var astNode = Statement(); // 解析 else 分支中的语句
|
||
while (_currentToken.Type == TokenType.Semicolon)
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
}
|
||
if (astNode != null)
|
||
{
|
||
falseBranch.Add(astNode); // 将 else 分支的语句添加到 falseBranch 中
|
||
}
|
||
}
|
||
// 确保匹配右大括号 }
|
||
if (_currentToken.Type != TokenType.BraceRight)
|
||
{
|
||
throw new Exception("Expected '}' after if block");
|
||
}
|
||
_currentToken = _lexer.NextToken(); // Consume "}"
|
||
}
|
||
|
||
|
||
return new IfNode(condition, trueBranch, falseBranch).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析 while 循环语句。
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private ASTNode ParseWhile()
|
||
{
|
||
_currentToken = _lexer.NextToken(); // Consume "while"
|
||
_currentToken = _lexer.NextToken(); // Consume "("
|
||
ASTNode condition = BooleanExpression();
|
||
//ASTNode condition = Expression();
|
||
_currentToken = _lexer.NextToken(); // Consume ")"
|
||
_currentToken = _lexer.NextToken(); // Consume "{"
|
||
List<ASTNode> body = new List<ASTNode>();
|
||
while (_currentToken.Type != TokenType.BraceRight)
|
||
{
|
||
body.Add(Statement()); // 解析循环体中的语句
|
||
}
|
||
_currentToken = _lexer.NextToken(); // Consume "}"
|
||
return new WhileNode(condition, body).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 顶层布尔表达式
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private ASTNode BooleanExpression()
|
||
{
|
||
ASTNode left = ComparisonExpression();
|
||
|
||
while (_currentToken.Type == TokenType.Operator &&
|
||
(_currentToken.Value == "&&" || _currentToken.Value == "||"))
|
||
{
|
||
string op = _currentToken.Value;
|
||
_currentToken = _lexer.NextToken();
|
||
ASTNode right = ComparisonExpression();
|
||
left = new BinaryOperationNode(left, op, right).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
return left;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 比较表达式（==, !=, <, <=, >, >=）
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private ASTNode ComparisonExpression()
|
||
{
|
||
ASTNode left = Expression();
|
||
|
||
while (_currentToken.Type == TokenType.Operator &&
|
||
(_currentToken.Value == "==" || _currentToken.Value == "!=" ||
|
||
_currentToken.Value == "<" || _currentToken.Value == "<=" ||
|
||
_currentToken.Value == ">" || _currentToken.Value == ">="))
|
||
{
|
||
string op = _currentToken.Value;
|
||
_currentToken = _lexer.NextToken();
|
||
ASTNode right = Expression();
|
||
left = new BinaryOperationNode(left, op, right).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
return left;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 加减
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private ASTNode Expression()
|
||
{
|
||
ASTNode left = Term();
|
||
|
||
while (_currentToken.Type == TokenType.Operator &&
|
||
(_currentToken.Value == "+" || _currentToken.Value == "-"))
|
||
{
|
||
string op = _currentToken.Value;
|
||
_currentToken = _lexer.NextToken();
|
||
ASTNode right = Term();
|
||
left = new BinaryOperationNode(left, op, right).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
return left;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 乘除
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private ASTNode Term()
|
||
{
|
||
ASTNode left = Factor();
|
||
|
||
while (_currentToken.Type == TokenType.Operator &&
|
||
(_currentToken.Value == "*" || _currentToken.Value == "/"))
|
||
{
|
||
string op = _currentToken.Value;
|
||
_currentToken = _lexer.NextToken();
|
||
ASTNode right = Factor();
|
||
left = new BinaryOperationNode(left, op, right).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
return left;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析因子（Factor），用于处理基本的字面量、标识符、括号表达式等。
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
private ASTNode Factor()
|
||
{
|
||
|
||
|
||
#region 返回字面量
|
||
if (_currentToken.Type == TokenType.Null)
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗 null
|
||
return new NullNode().SetTokenInfo(_currentToken);
|
||
}
|
||
if (_currentToken.Type == TokenType.Boolean)
|
||
{
|
||
var value = bool.Parse(_currentToken.Value);
|
||
_currentToken = _lexer.NextToken(); // 消耗布尔量
|
||
return new BooleanNode(value).SetTokenInfo(_currentToken);
|
||
}
|
||
if (_currentToken.Type == TokenType.String)
|
||
{
|
||
var text = _currentToken.Value;
|
||
var node = new StringNode(text).SetTokenInfo(_currentToken);
|
||
_currentToken = _lexer.NextToken(); // 消耗字符串
|
||
return node;
|
||
}
|
||
if (_currentToken.Type == TokenType.Char)
|
||
{
|
||
var text = _currentToken.Value;
|
||
_currentToken = _lexer.NextToken(); // 消耗Char
|
||
return new CharNode(text).SetTokenInfo(_currentToken);
|
||
}
|
||
if( _currentToken.Type == TokenType.InterpolatedString)
|
||
{
|
||
// 暂未实现插值字符串
|
||
// 可能是插值字符串；
|
||
// let context = $"a{A}b{B}c";
|
||
// let context = "a" + A + "b" + B + c;
|
||
_currentToken = _lexer.NextToken(); // 消耗字符串
|
||
while (_currentToken.Type == TokenType.String) {
|
||
}
|
||
}
|
||
|
||
if (_currentToken.Type == TokenType.NumberInt)
|
||
{
|
||
var value = int.Parse(_currentToken.Value);
|
||
_currentToken = _lexer.NextToken(); // 消耗 int 整型
|
||
return new NumberIntNode(value).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
if (_currentToken.Type == TokenType.NumberLong)
|
||
{
|
||
var value = long.Parse(_currentToken.Value);
|
||
_currentToken = _lexer.NextToken(); // 消耗
|
||
return new NumberLongNode(value).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
if (_currentToken.Type == TokenType.NumberFloat)
|
||
{
|
||
var value = float.Parse(_currentToken.Value);
|
||
_currentToken = _lexer.NextToken(); // 消耗数字
|
||
return new NumberFloatNode(value).SetTokenInfo(_currentToken);
|
||
}
|
||
|
||
if (_currentToken.Type == TokenType.NumberDouble)
|
||
{
|
||
var value = float.Parse(_currentToken.Value);
|
||
_currentToken = _lexer.NextToken(); // 消耗数字
|
||
return new NumberDoubleNode(value).SetTokenInfo(_currentToken);
|
||
}
|
||
#endregion
|
||
|
||
// 标识符节点
|
||
if (_currentToken.Type == TokenType.Identifier)
|
||
{
|
||
var _identifierPeekToken = _lexer.PeekToken();
|
||
if (_identifierPeekToken.Type is (TokenType.Dot and TokenType.ParenthesisLeft) or TokenType.Semicolon or TokenType.Comma)
|
||
{
|
||
// 不是 "." 号，也不是 "(" , 或是";"，则是获取变量
|
||
var node = new IdentifierNode(_currentToken.Value).SetTokenInfo(_currentToken); // 获取变量
|
||
_currentToken = _lexer.NextToken(); // 消耗变量
|
||
return node;
|
||
}
|
||
if (_identifierPeekToken.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 可能是挂载函数调用
|
||
var functionCallNode = ParseFunctionCall();
|
||
return functionCallNode;
|
||
}
|
||
var objToken = _currentToken; // 对象Token
|
||
ASTNode? objectNode = new IdentifierNode(objToken.Value).SetTokenInfo(objToken); // 对象节点
|
||
var identifier = _currentToken.Value; // 标识符字面量
|
||
List<ASTNode> nodes = new List<ASTNode>();
|
||
while (true)
|
||
{
|
||
if (_currentToken.Type == TokenType.Dot)
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
if (_currentToken.Type == TokenType.Identifier)
|
||
{
|
||
var temp2token = _lexer.PeekToken();
|
||
var sourceNode = (nodes.Count == 0 ? objectNode : nodes[^1]);
|
||
if (temp2token.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 解析方法调用 obj.func()
|
||
ASTNode functionNode = ParseMemberFunctionCall(sourceNode).SetTokenInfo(_currentToken);
|
||
nodes.Add(functionNode);
|
||
}
|
||
else if (temp2token.Type == TokenType.SquareBracketsLeft)
|
||
{
|
||
// 成员数组 obj.dict[key] / obj.array[index]
|
||
if (_currentToken.Type == TokenType.Identifier)
|
||
{
|
||
sourceNode = new MemberAccessNode(sourceNode, _currentToken.Value).SetTokenInfo(_currentToken);
|
||
}
|
||
var coolectionNode = ParseCollectionIndex(sourceNode).SetTokenInfo(_currentToken);
|
||
nodes.Add(coolectionNode);
|
||
}
|
||
else if (temp2token.Type is TokenType.Operator or TokenType.Dot or TokenType.Semicolon or TokenType.ParenthesisRight)
|
||
{
|
||
// 成员获取 obj.value
|
||
var memberAccessNode = new MemberAccessNode(sourceNode, _currentToken.Value).SetTokenInfo(_currentToken);
|
||
nodes.Add(memberAccessNode);
|
||
}
|
||
//_lexer.SetToken(peekToken); // 重置lexer
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_currentToken = _lexer.NextToken();
|
||
}
|
||
if (_currentToken.Type is TokenType.Operator)
|
||
{
|
||
// 分号意味着语句结束
|
||
break;
|
||
}if (_currentToken.Type is TokenType.Semicolon)
|
||
{
|
||
// 分号意味着语句结束
|
||
break;
|
||
}
|
||
}
|
||
if (nodes.Count == 0)
|
||
{
|
||
return objectNode;
|
||
}
|
||
else
|
||
{
|
||
var node = nodes[^1];
|
||
var objNode = new ObjectMemberExpressionNode(node).SetTokenInfo(objToken);
|
||
return objNode;
|
||
}
|
||
|
||
|
||
|
||
/* var _identifierPeekToken = _lexer.PeekToken();
|
||
// 该标识符是方法调用
|
||
if (_identifierPeekToken.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
// 可能是函数调用
|
||
return ParseFunctionCall();
|
||
}
|
||
|
||
// 需要从该标识符调用另一个标识符
|
||
if (_identifierPeekToken.Type == TokenType.Dot)
|
||
{
|
||
// 可能是成员访问或成员赋值
|
||
return ParseMemberAccessOrAssignment(); // 二元操作中获取对象成员
|
||
}
|
||
|
||
|
||
// 数组 index; 字典 key obj.Member[xxx];
|
||
if (_identifierPeekToken.Type == TokenType.SquareBracketsLeft)
|
||
{
|
||
return ParseCollectionIndex();
|
||
}
|
||
|
||
_currentToken = _lexer.NextToken(); // 消耗标识符
|
||
return new IdentifierNode(identifier.ToString()).SetTokenInfo(_currentToken);*/
|
||
}
|
||
|
||
|
||
|
||
// 方法调用
|
||
if (_currentToken.Type == TokenType.ParenthesisLeft)
|
||
{
|
||
_currentToken = _lexer.NextToken(); // 消耗 "("
|
||
var expr = BooleanExpression();
|
||
//var expr = Expression();
|
||
if (_currentToken.Type != TokenType.ParenthesisRight)
|
||
throw new Exception("非预期的符号，预期符号为\")\"。");
|
||
_currentToken = _lexer.NextToken(); // 消耗 ")"
|
||
return expr;
|
||
}
|
||
|
||
// 创建对象
|
||
if (_currentToken.Type == TokenType.Keyword && _currentToken.Value == "new")
|
||
{
|
||
// 可能是对象实例化
|
||
return ParseObjectInstantiation();
|
||
}
|
||
|
||
|
||
|
||
|
||
throw new Exception($"在Expression().Factor()遇到意外的 Token Type ,{_currentToken.Type} {_currentToken.Value} " );
|
||
}
|
||
}
|
||
|
||
}
|
