// 计算元组的值
private object calcuTupleValue(ASTNode_TupleExpression Expression, int LineNumber)
{
// 根据元组的成员数进行转换
if (Expression.Args.Count < 2)
{
throw new RuntimeException(LineNumber, "internal error.");
}
else if (Expression.Args.Count == 2)
{
// 计算值
object tX = ExecExpression(Expression.Args[0]);
object tY = ExecExpression(Expression.Args[1]);
if (!(tX is double) || !(tY is double))
{
throw new RuntimeException(LineNumber, "tuple element must be a digit.");
}
return(new Vector2 {
x = (double)tX, y = (double)tY
});
}
else
{
throw new RuntimeException(LineNumber, "tuple element count must be two.");
}
}
/// <summary>
/// 执行一个表达式
/// </summary>
/// <param name="Expression">表达式语法树</param>
/// <returns>执行结果</returns>
public object ExecExpression(ASTNode_Expression Expression)
{
switch (Expression.Type)
{
case ASTNode.ASTType.BinaryExpression:
{
ASTNode_BinaryExpression tBinaryExpression = (ASTNode_BinaryExpression)Expression;
object tLeftResult = ExecExpression(tBinaryExpression.Left);
object tRightResult = ExecExpression(tBinaryExpression.Right);
return(applyBinaryOperator(tBinaryExpression.BinaryOperator, tLeftResult, tRightResult, Expression.LineNumber));
}
case ASTNode.ASTType.UnaryExpression:
{
ASTNode_UnaryExpression tUnaryExpression = (ASTNode_UnaryExpression)Expression;
object tRightResult = ExecExpression(tUnaryExpression.Right);
return(applyUnaryOperator(tUnaryExpression.UnaryOperator, tRightResult, Expression.LineNumber));
}
case ASTNode.ASTType.DigitLiteral:
{
ASTNode_DigitLiteral tDigitLiteral = (ASTNode_DigitLiteral)Expression;
return(tDigitLiteral.Value);
}
case ASTNode.ASTType.CallExpression:
{
ASTNode_CallExpression tCallExpression = (ASTNode_CallExpression)Expression;
return(applyCallOperator(
tCallExpression.Identifier,
tCallExpression.IdentifierLower,
tCallExpression.ArgList,
Expression.LineNumber
));
}
case ASTNode.ASTType.SymbolExpression:
{
ASTNode_SymbolExpression tSymbolExpression = (ASTNode_SymbolExpression)Expression;
return(fetchValueOfIdentifier(
tSymbolExpression.Identifier,
tSymbolExpression.IdentifierLower,
Expression.LineNumber
));
}
case ASTNode.ASTType.TupleExpression:
{
ASTNode_TupleExpression tTupleExpression = (ASTNode_TupleExpression)Expression;
return(calcuTupleValue(tTupleExpression, Expression.LineNumber));
}
default:
throw new RuntimeException(Expression.LineNumber, "internal error.");
}
}
/// <summary>
/// 解析括号表达式
///
/// 括号表达式不可为空，当仅有一个元素时表达为单值，当有多个元素时表达为向量
/// </summary>
/// <param name="Lex">词法分析器</param>
/// <returns>解析结果</returns>
private static ASTNode_Expression ParseBracketExpression(Lexer Lex)
{
// 先读取第一个表达式
ASTNode_Expression tFirstExpr = ParseExpression(Lex);
// 检查后续元素
if (Lex.CurrentToken != Lexer.Token.RightBracket)
{
ASTNode_TupleExpression tList = new ASTNode_TupleExpression(Lex.Line);
tList.Args.Add(tFirstExpr);
while (true)
{
MatchToken(Lex, Lexer.Token.Comma); // ','
tList.Args.Add(ParseExpression(Lex));
if (Lex.CurrentToken == Lexer.Token.Comma) // peek ','
{
continue;
}
if (Lex.CurrentToken == Lexer.Token.RightBracket) // peek ')'
{
break;
}
else
{
throw new SyntaxException(Lex.Position, Lex.Line, Lex.Row,
String.Format("unexpected token {0}.", Lex.FormatCurrentToken()));
}
}
return(tList);
}
else
{
return(tFirstExpr);
}
}
