private static LiteralExpression Clone(LiteralExpression expression)
{
return expression;
}
public bool Equals(LiteralExpression other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return Equals(other.Literal, Literal);
}
protected virtual void Visit(MixinStatement mixinStatement)
{
Expression mixinName;
AssignmentExpression assignExpression;
var genericParameters = new List<Expression>();
switch (mixinStatement.Type)
{
case MixinStatementType.Default:
ExtractGenericParameters(mixinStatement.Value, out mixinName, genericParameters);
WriteLinkLine(mixinStatement);
Write("context.Mixin(mixin, ");
WriteMixinName(mixinName);
WriteGenericParameters(genericParameters);
WriteLine(");");
break;
case MixinStatementType.Child:
// mixin child can come in 2 flavour:
// 1) mixin child MyEffect => equivalent to mixin child MyEffect = MyEffect
// 2) mixin child MyGenericEffectName = MyEffect
var targetExpression = mixinStatement.Value;
assignExpression = mixinStatement.Value as AssignmentExpression;
if (assignExpression != null)
{
targetExpression = assignExpression.Value;
}
ExtractGenericParameters(targetExpression, out mixinName, genericParameters);
var childName = assignExpression != null ? assignExpression.Target : mixinName;
{
WriteLinkLine(mixinStatement);
Write("if (context.ChildEffectName == ");
WriteMixinName(childName);
Write(")");
OpenBrace();
WriteLinkLine(mixinStatement);
Write("context.Mixin(mixin, ");
WriteMixinName(mixinName);
WriteGenericParameters(genericParameters);
WriteLine(");");
WriteLine("return;");
CloseBrace();
}
break;
case MixinStatementType.Remove:
ExtractGenericParameters(mixinStatement.Value, out mixinName, genericParameters);
WriteLinkLine(mixinStatement);
Write("context.RemoveMixin(mixin, ");
WriteMixinName(mixinName);
if (genericParameters.Count > 0)
{
logging.Error("Removing with generic parameters is not supported", mixinStatement.Span);
}
WriteLine(");");
break;
case MixinStatementType.Macro:
WriteLinkLine(mixinStatement);
var context = (ShaderBlockContext)currentBlock.GetTag(BlockContextTag);
assignExpression = mixinStatement.Value as AssignmentExpression;
Expression macroName;
Expression macroValue;
if (assignExpression != null)
{
macroName = assignExpression.Target;
if (macroName is VariableReferenceExpression)
{
macroName = new LiteralExpression(macroName.ToString());
}
macroValue = assignExpression.Value;
}
else
{
var variableReference = mixinStatement.Value as MemberReferenceExpression;
if (variableReference == null || !(variableReference.Target is VariableReferenceExpression) || !context.DeclaredParameters.Contains((((VariableReferenceExpression)variableReference.Target).Name.Text)))
{
logging.Error("Invalid syntax. Expecting: mixin macro Parameters.NameOfProperty or mixin macro nameOfProperty = value", mixinStatement.Span);
macroName = new LiteralExpression("#INVALID_MACRO_NAME");
macroValue = mixinStatement.Value;
}
else
{
macroName = new LiteralExpression(variableReference.Member.Text);
macroValue = mixinStatement.Value;
}
}
Write("mixin.AddMacro(");
VisitDynamic(macroName);
Write(", ");
VisitDynamic(macroValue);
WriteLine(");");
break;
case MixinStatementType.Compose:
assignExpression = mixinStatement.Value as AssignmentExpression;
if (assignExpression == null)
{
logging.Error("Expecting assign expression for composition", mixinStatement.Value.Span);
return;
}
var addCompositionFunction = "PushComposition";
// If it's a +=, let's create or complete a ShaderArraySource
if (assignExpression.Operator == AssignmentOperator.Addition)
{
addCompositionFunction = "PushCompositionArray";
}
ExtractGenericParameters(assignExpression.Value, out mixinName, genericParameters);
{
OpenBrace();
WriteLinkLine(mixinStatement);
Write("var __mixinToCompose__ = ");
WriteMixinName(mixinName);
WriteLine(";");
WriteLine("var __subMixin = new ShaderMixinSource();");
WriteLinkLine(mixinStatement);
Write("context.").Write(addCompositionFunction).Write("(mixin, ");
WriteStringOrExpression(assignExpression.Target);
WriteLine(", __subMixin);");
WriteLinkLine(mixinStatement);
Write("context.Mixin(__subMixin, __mixinToCompose__");
WriteGenericParameters(genericParameters);
WriteLine(");");
WriteLinkLine(mixinStatement);
WriteLine("context.PopComposition();");
CloseBrace();
}
break;
}
}
/// <inheritdoc/>
public override void Visit(LiteralExpression literalExpression)
{
try
{
var value = Convert.ToDouble(literalExpression.Literal.Value, CultureInfo.InvariantCulture);
values.Push(value);
}
catch (Exception)
{
result.Error("Unable to convert value [{0}] to double", literalExpression.Span, literalExpression.Literal.Value);
}
}
protected virtual void Visit(LiteralExpression literalExpression)
{
Visit((Node)literalExpression);
if (literalExpression.Value is int)
literalExpression.TypeInference.TargetType = ScalarType.Int;
if (literalExpression.Value is uint)
literalExpression.TypeInference.TargetType = ScalarType.UInt;
if (literalExpression.Value is float)
literalExpression.TypeInference.TargetType = ScalarType.Float;
if (literalExpression.Value is double)
literalExpression.TypeInference.TargetType = ScalarType.Double;
if (literalExpression.Value is bool)
literalExpression.TypeInference.TargetType = ScalarType.Bool;
if (literalExpression.Value is string)
literalExpression.TypeInference.TargetType = TypeBase.String;
if (literalExpression.TypeInference.TargetType == null)
{
Error(MessageCode.ErrorLiteralType, literalExpression.Span, literalExpression.Text);
}
}
/// <summary>
/// Visits the specified literal expression.
/// </summary>
/// <param name="literalExpression">The literal expression.</param>
public override Node Visit(LiteralExpression literalExpression)
{
base.Visit(literalExpression);
if (literalExpression.Value is int)
literalExpression.TypeInference.TargetType = ScalarType.Int;
if (literalExpression.Value is uint)
literalExpression.TypeInference.TargetType = ScalarType.UInt;
if (literalExpression.Value is float)
literalExpression.TypeInference.TargetType = ScalarType.Float;
if (literalExpression.Value is double)
literalExpression.TypeInference.TargetType = ScalarType.Double;
if (literalExpression.Value is bool)
literalExpression.TypeInference.TargetType = ScalarType.Bool;
if (literalExpression.Value is string)
literalExpression.TypeInference.TargetType = TypeBase.String;
if (literalExpression.TypeInference.TargetType == null)
{
Error(MessageCode.ErrorLiteralType, literalExpression.Span, literalExpression.Text);
}
return literalExpression;
}
