public ExpressionSimplifierVisitor()
: base(true, true)
{
evaluator = new ExpressionEvaluator();
}
/// <inheritdoc/>
public override void Visit(MethodInvocationExpression methodInvocationExpression)
{
if (methodInvocationExpression.Target is TypeReferenceExpression)
{
var methodName = (methodInvocationExpression.Target as TypeReferenceExpression).Type.Name.Text;
if (hlslScalarTypeNames.Contains(methodName))
{
var evaluator = new ExpressionEvaluator();
var subResult = evaluator.Evaluate(methodInvocationExpression.Arguments[0]);
values.Push(subResult.Value);
return;
}
}
result.Error("Method invocation expression evaluation [{0}] is not supported", methodInvocationExpression.Span, methodInvocationExpression);
}
/// <inheritdoc/>
public override void Visit(VariableReferenceExpression variableReferenceExpression)
{
base.Visit(variableReferenceExpression);
var variableDeclaration = variableReferenceExpression.TypeInference.Declaration as Variable;
if (variableDeclaration == null)
{
result.Error("Unable to find variable [{0}]", variableReferenceExpression.Span, variableReferenceExpression);
}
else if (variableDeclaration.InitialValue == null || !variableDeclaration.Qualifiers.Contains(StorageQualifier.Const))
{
result.Error("Variable [{0}] used in expression is not constant", variableReferenceExpression.Span, variableDeclaration);
}
else
{
var evaluator = new ExpressionEvaluator();
var subResult = evaluator.Evaluate(variableDeclaration.InitialValue);
subResult.CopyTo(result);
if (subResult.HasErrors)
{
values.Push(0.0);
}
else
{
values.Push(subResult.Value);
}
}
}
protected virtual ArrayType Visit(ArrayType arrayType)
{
Visit((Node)arrayType);
// Process only if there is non-literal expressions
if (arrayType.TypeInference.TargetType == null
&& arrayType.Dimensions.Any(x => !(x is LiteralExpression || x is EmptyExpression)))
{
// Try to evaluate each dimension into a Literal expression (i.e. float4[3 * 2] should become float4[6])
var evaluator = new ExpressionEvaluator();
var results = arrayType.Dimensions.Select(evaluator.Evaluate).ToArray();
if (results.Any(x => x.HasErrors))
{
foreach (var result in results.Where(x => x.HasErrors))
result.CopyTo(ParsingResult);
}
else
{
arrayType.TypeInference.TargetType = new ArrayType(arrayType.Type, results.Select(x => new LiteralExpression(Convert.ToInt32(x.Value))).ToArray());
}
}
return arrayType;
}
