private CobaltType AnalyzeUnaryExpression(UnaryExpressionNode unaryExpression)
{
CobaltType operandType;
if (unaryExpression.Operand is ExpressionNode operandExpression)
{
operandType = AnalyzeExpression(operandExpression);
}
else
{
operandType = AnalyzeExpressionLeaf(unaryExpression.Operand);
}
switch (unaryExpression)
{
case ArithmeticNegationNode _:
if (IsNumberType(operandType))
{
return(operandType);
}
throw new CobaltTypeError($"An arithmetic negation (`~`) cannot be applied on an operand of type `{operandType}`.", unaryExpression.SourceLine);
case LogicalNegationNode _:
if (operandType == CobaltType.Boolean)
{
return(operandType);
}
throw new CobaltTypeError($"A logical negation (`!`) cannot be applied on an operand of type `{operandType}`.", unaryExpression.SourceLine);
default:
throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` does not contain an implementation for the unary expression type `{unaryExpression.GetType()}`.");
}
}
protected override CrawlSyntaxNode VisitUnaryExpression(UnaryExpressionNode expression)
{
CrawlSyntaxNode result;
UnaryExpressionNode expr = (UnaryExpressionNode)base.VisitUnaryExpression(expression);
switch (expr.ExpressionType)
{
case ExpressionType.Negate:
result = expr.WithResultType(
UnaryNegate(expr.Target.ResultType)
);
break;
case ExpressionType.Not:
result = expr.WithResultType(
UnaryNot(expr.Target.ResultType)
);
break;
default:
throw new InvalidEnumArgumentException("Invalid type of unary operator");
}
return(result);
}
protected override List <AssemblyElement> VisitUnaryExpression(UnaryExpressionNode node)
{
List <AssemblyElement> instructions = new List <AssemblyElement>();
instructions.AddRange(Visit(node.ExpressionNode));
if (node.DoGenerateOperatorInstruction)
{
switch (node.Operator)
{
case UnaryOperator.Minus:
instructions.Add(new Minus());
break;
case UnaryOperator.Not:
instructions.Add(new Not());
break;
case UnaryOperator.Negate:
instructions.Add(new Negate());
break;
case UnaryOperator.Plus:
instructions.Add(new Plus());
break;
}
}
return(instructions);
}
public bool VisitUnaryExpressionNode(UnaryExpressionNode node, CompilationState state)
{
WriteUnaryOperator(state, node.Operator);
EncapsulateOrNot(state, node.Operand);
return(true);
}
private void GenerateUnaryExpressionCode(StringBuilder builder, UnaryExpressionNode unaryExpression)
{
switch (unaryExpression)
{
case ArithmeticNegationNode _:
builder.Append("-");
break;
case LogicalNegationNode _:
builder.Append("!");
break;
default:
throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` called with bad AST stucture. Expected an unary expression node.");
}
builder.Append("(");
if (unaryExpression.Operand is ExpressionNode expression)
{
GenerateExpressionCode(builder, expression);
}
else
{
GenerateExpressionLeafCode(builder, unaryExpression.Operand);
}
builder.Append(")");
}
public bool VisitUnaryExpressionNode(UnaryExpressionNode node, CompilationState state)
{
WriteUnaryOperator(state, node.Operator);
node.Operand.AcceptVisitor(this, state);
return(true);
}
private UnaryExpressionNode ParseUnaryExpression()
{
UnaryExpressionNode ret = NewNode <UnaryExpressionNode>();
NextToken();
ret.Value = ParseExpression(13);
return(ret);
}
private Expression ParseUnaryExpression(UnaryExpressionNode node)
{
if (node.Token == TokenType.NOT)
{
return(Expression.Not(CompileExpression(node.Value, ValueTypes.BOOL)));
}
throw new Exception("hello");
}
public object Visit(UnaryExpressionNode n, object o)
{
Append("("); // add parenthesis to ensure correct order of evaluation
n.Operator.Accept(this, null);
n.Child.Accept(this, null);
Append(")");
return(null);
}
public void Parse_UnaryExpression_Minus()
{
ASTNode root = ExpressionParser.Parse("-someValue");
UnaryExpressionNode node = AssertInstanceOfAndReturn <UnaryExpressionNode>(root);
Assert.AreEqual(ASTNodeType.UnaryMinus, node.type);
Assert.IsInstanceOf <IdentifierNode>(node.expression);
}
public void Parse_UnaryExpression_Minus_Complex()
{
ASTNode root = ExpressionParser.Parse("-(someValue + 4)");
UnaryExpressionNode node = AssertInstanceOfAndReturn <UnaryExpressionNode>(root);
Assert.AreEqual(ASTNodeType.UnaryMinus, node.type);
Assert.IsInstanceOf <ParenNode>(node.expression);
}
public override bool VisitUnaryExpressionNode(UnaryExpressionNode node)
{
if (forDefinition)
{
return(false);
}
return(node.Expression.Accept(this));
}
public void Parse_UnaryExpression_DirectCastGeneric()
{
ASTNode root = ExpressionParser.Parse("(List<float, int>)someIdentifier");
UnaryExpressionNode node = AssertInstanceOfAndReturn <UnaryExpressionNode>(root);
Assert.AreEqual(ASTNodeType.DirectCast, node.type);
Assert.AreEqual("List", node.typeLookup.typeName);
Assert.AreEqual("float", node.typeLookup.generics[0].typeName);
Assert.AreEqual("int", node.typeLookup.generics[1].typeName);
}
private static PythonNode Wrap(UnaryExpression exp, PythonNode parent)
{
var result = new UnaryExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Expression, result));
result.Value = exp.Op;
return(result);
}
private Type Build(UnaryExpressionNode node)
{
if (node.Op == "NOT")
{
return(typeof(bool));
}
else
{
return(InnerBuild(node.Argument));
}
}
private EbiValueBase Evaluate(EbiScope scope, ExpressionNode expr)
{
return(expr switch
{
LiteralNode l => l.Value,
IdentifierNode id => scope[id.Name]?.Value ?? throw new RuntimeException($"No such identifier named '{id.Name}'"),
CallExpressionNode call => Evaluate(scope, call),
UnaryExpressionNode un => Evaluate(scope, un),
BinaryExpressionNode bin => Evaluate(scope, bin),
_ => new EbiNull(),
});
public override AssociativeNode VisitUnaryExpressionNode(UnaryExpressionNode node)
{
var newExpression = node.Expression.Accept(this);
if (node.Expression != newExpression)
{
node.Expression = newExpression;
}
return(node);
}
public override void Visit(UnaryExpressionNode node)
{
if (node.Parenthesized)
{
Emit("(");
}
PrintExpression(node);
if (node.Parenthesized)
{
Emit(")");
}
}
public virtual Value evaluate(Context cx, UnaryExpressionNode node)
{
output("<UnaryExpressionNode position=\"" + node.pos() + "\">");
indent_Renamed_Field++;
if (node.expr != null)
{
node.expr.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</UnaryExpressionNode>");
return(null);
}
public void Parse_UnaryExpression_DirectCast()
{
ASTNode root = ExpressionParser.Parse("(int)5.6f");
UnaryExpressionNode node = AssertInstanceOfAndReturn <UnaryExpressionNode>(root);
Assert.AreEqual(ASTNodeType.DirectCast, node.type);
Assert.AreEqual("int", node.typeLookup.typeName);
root = ExpressionParser.Parse("(UnityEngine.Vector3)5.6f");
node = AssertInstanceOfAndReturn <UnaryExpressionNode>(root);
Assert.AreEqual(ASTNodeType.DirectCast, node.type);
Assert.AreEqual("UnityEngine", node.typeLookup.namespaceName);
Assert.AreEqual("Vector3", node.typeLookup.typeName);
}
void unaryexpr(out Node node)
{
node = null;
UnaryOperator op;
Node exprNode;
unaryop(out op);
expr(out exprNode);
UnaryExpressionNode unary = new UnaryExpressionNode();
unary.Operator = op;
unary.Expression = exprNode;
node = unary;
}
public override Type visitUnary(UnaryExpressionNode unary, Environment env)
{
Type operandType = analyzeExpr(unary.operand, env);
if (unary.opcode.isIncDec() && !unary.operand.IsLValue)
{
log.error(unary.Pos, messages.incDecArgument);
}
OperatorSymbol op = operators.resolveUnary(unary.Pos, unary.opcode, operandType);
unary.operatorSym = op;
return(op.type.ReturnType);
}
private void PrintExpression(UnaryExpressionNode node)
{
if (node is UnaryMinusNode && node.Type is "tensor")
{
Emit("scalarmul(-1, ");
Visit(node.Inner);
Emit(")");
}
else
{
Emit(node is NotNode ? "!" : "-");
Visit(node.Inner);
}
}
public void Parse_UnaryExpression_DirectCastGenericList()
{
ASTNode root = ExpressionParser.Parse("(List<Something.Tuple<int, ValueTuple>>)expr");
UnaryExpressionNode node = AssertInstanceOfAndReturn <UnaryExpressionNode>(root);
Assert.AreEqual("List", node.typeLookup.typeName);
TypeLookup outerTuple = node.typeLookup.generics[0];
TypeLookup outerGen0 = outerTuple.generics[0];
TypeLookup outerGen1 = outerTuple.generics[1];
Assert.AreEqual("Something", outerTuple.namespaceName);
Assert.AreEqual("Tuple", outerTuple.typeName);
Assert.AreEqual("int", outerGen0.typeName);
Assert.AreEqual("ValueTuple", outerGen1.typeName);
}
public override void Visit(UnaryExpressionNode node)
{
switch (node)
{
case NotNode:
Console.WriteLine("not");
break;
default:
throw new NotSupportedException();
}
i += 2;
VisitChildren(node, Inden());
i -= 2;
}
protected override CrawlSyntaxNode VisitUnaryExpression(UnaryExpressionNode unaryExpression)
{
CrawlSyntaxNode expr = base.VisitUnaryExpression(unaryExpression);
UnaryExpressionNode unaryExpr = expr as UnaryExpressionNode;
if (unaryExpr == null)
{
return(expr);
}
OptimizationsWereMade = true;
ExpressionNode tar = unaryExpr.Target;
return(FoldUnary(tar, unaryExpression.ExpressionType));
}
public MultipicativeExpressionNode(ExpressionNode leftExpression,
UnaryExpressionNode unaryExpression, Token token) : base(leftExpression, unaryExpression, token)
{
var tInt = new IntTypeNode();
var tFloat = new FloatTypeNode();
rules[Utils.Int + "," + Utils.Int] = tInt;
rules[Utils.Char + "," + Utils.Int] = tInt;
rules[Utils.Int + "," + Utils.Char] = tInt;
rules[Utils.Int + "," + Utils.Float] = tFloat;
rules[Utils.Float + "," + Utils.Int] = tFloat;
rules[Utils.Float + "," + Utils.Float] = tFloat;
rules[Utils.Float + "," + Utils.Char] = tFloat;
rules[Utils.Char + "," + Utils.Float] = tFloat;
rules[Utils.Char + "," + Utils.Char] = tInt;
}
private ExpressionNode Unary()
{
ExpressionNode itsAST;
SourceCodePosition itsPos = _currentToken.SourcePosition;
if (_currentToken.Type == Token.TokenType.AdditiveOperator)
{
OperatorNode op = new OperatorNode(_currentToken.Value, _currentToken.SourcePosition);
Accept(Token.TokenType.AdditiveOperator);
ExpressionNode child = Unary();
itsAST = new UnaryExpressionNode(op, child, itsPos);
}
else
{
itsAST = Exponent();
}
return(itsAST);
}
private ExpressionNode BooleanNot()
{
ExpressionNode itsAST;
SourceCodePosition itsPos = _currentToken.SourcePosition;
if (_currentToken.Type == Token.TokenType.Not)
{
OperatorNode op = new OperatorNode(_currentToken.Value, _currentToken.SourcePosition);
Accept(Token.TokenType.Not);
ExpressionNode child = BooleanNot();
itsAST = new UnaryExpressionNode(op, child, itsPos);
}
else
{
itsAST = Compare();
}
return(itsAST);
}
public override void Visit(UnaryExpressionNode node)
{
base.Visit(node);
switch (node)
{
case NotNode:
if (node.Inner.Type != "bool")
{
throw new InvalidOperandsException(node,
"The operand of a bool operator can only be bool. It does not allow int, double or tensor.");
}
else
{
node.Type = "bool";
}
break;
case UnaryMinusNode:
switch (node.Inner.Type)
{
case "int":
node.Type = "int";
break;
case "double":
node.Type = "double";
break;
case "tensor":
node.Rows = node.Inner.Rows;
node.Columns = node.Inner.Columns;
break;
default:
throw new InvalidOperandsException(node,
"The operand of a arithmetic operator can not be bool. It does only allow int, double or tensor.");
}
break;
default:
throw new NotSupportedException();
}
}
public UnaryExpressionNode(UnaryExpressionNode rhs) : base(rhs)
{
Operator = rhs.Operator;
Expression = ProtoCore.Utils.NodeUtils.Clone(rhs.Expression);
}
public virtual Value evaluate(Context cx, UnaryExpressionNode node)
{
output("<UnaryExpressionNode position=\"" + node.pos() + "\">");
indent_Renamed_Field++;
if (node.expr != null)
{
node.expr.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</UnaryExpressionNode>");
return null;
}
