public string Visit(StructExpression node)
{
var codeWriter = new XzaarCodeWriter();
codeWriter.Write("class " + node.Name + " {", currentIndent);
codeWriter.NewLine();
currentIndent++;
if (node.Fields != null && node.Fields.Length > 0)
{
codeWriter.Write("constructor(", currentIndent);
var fieldNames = node.Fields.Select(x => Visit(x).TrimWsRn()).ToArray();
codeWriter.WriteLine(string.Join(", ", fieldNames) + ") {");
currentIndent++;
codeWriter.WriteLine(string.Join(Environment.NewLine, fieldNames.Select(x => $"this.{x} = {x};")), currentIndent);
currentIndent--;
codeWriter.WriteLine("}", currentIndent);
}
currentIndent--;
codeWriter.Write("}", currentIndent);
codeWriter.NewLine();
return(codeWriter.ToString());
}
public void TestListExpression()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
VariableUpdateStatement statement = parser.Statement(rc, "V <- [S1 { E1 => Tr", true, true) as VariableUpdateStatement;
Assert.IsNotNull(statement);
UnaryExpression unaryExpression = statement.Expression as UnaryExpression;
Assert.IsNotNull(unaryExpression);
ListExpression listExpression = unaryExpression.Term.LiteralValue as ListExpression;
Assert.IsNotNull(listExpression);
Assert.AreEqual(listExpression.ListElements.Count, 1);
StructExpression structExpression = listExpression.ListElements[0] as StructExpression;
Assert.IsNotNull(structExpression);
}
}
/// <summary>
/// Visits a struct expression
/// </summary>
/// <param name="structExpression"></param>
protected override void VisitStructExpression(StructExpression structExpression)
{
ModelElement backup = User;
Structure structure = null;
if (structExpression.Structure != null)
{
structure = structExpression.Structure.GetExpressionType() as Structure;
VisitExpression(structExpression.Structure);
}
foreach (KeyValuePair <Designator, Expression> pair in structExpression.Associations)
{
ResetRemoveIndexes();
if (pair.Key != null)
{
User = structure;
VisitDesignator(pair.Key);
User = backup;
}
ResetRemoveIndexes();
if (pair.Value != null)
{
VisitExpression(pair.Value);
}
}
}
public static XzaarType CreateTypeFromStructExpression(StructExpression typeExpression)
{
var newType = new XzaarTypeBuilder(typeExpression.Name, null, Any, Any, null);
foreach (var f in typeExpression.Fields)
{
if (f is FieldExpression fn)
{
newType.AddField(fn.Type, fn.Name);
}
}
return(newType);
}
public TypeDefinition Visit(StructExpression node)
{
var typeName = node.Name;
var newStruct = new TypeDefinition(typeName, true);
var items = node.Fields.Select(Visit).Cast <VariableReference>();
foreach (var item in items)
{
newStruct.Fields.Add(item);
}
ctx.KnownTypes.Add(newStruct);
ctx.Assembly.Types.Add(newStruct);
return(newStruct);
}
public static bool TryGetType(string typeName, StructExpression typeExpression, out XzaarType newType)
{
var a = GetType(typeName);
if (a == null || Equals(a, XzaarBaseTypes.Void) || Equals(a, XzaarBaseTypes.Any))
{
newType = XzaarBaseTypes.CreateTypeFromStructExpression(typeExpression);
XzaarBaseTypes.AddTypeToCache(newType);
}
else
{
newType = a;
}
return(true);
}
public string Visit(StructExpression node)
{
var codeWriter = new XzaarCodeWriter();
codeWriter.Write("struct " + node.Name + " {", currentIndent);
codeWriter.NewLine();
currentIndent++;
foreach (var field in node.Fields)
{
codeWriter.Write(Visit(field));
}
currentIndent--;
codeWriter.Write("}", currentIndent);
codeWriter.NewLine();
return(codeWriter.ToString());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="structureExpression"></param>
/// <param name="context"></param>
/// <param name="explain"></param>
public StructureValue(StructExpression structureExpression, InterpretationContext context,
ExplanationPart explain)
: base(structureExpression.GetExpressionType() as Structure, new Dictionary <string, INamable>())
{
Enclosing = Structure;
try
{
HashSet <string> members = new HashSet <string>();
foreach (KeyValuePair <Designator, Expression> pair in structureExpression.Associations)
{
StructureElement structureElement = Structure.FindStructureElement(pair.Key.Image);
if (structureElement != null)
{
IValue val = pair.Value.GetExpressionValue(new InterpretationContext(context), explain);
if (val != null)
{
Field field = CreateField(structureElement, structureExpression.RootLog);
field.Value = val;
members.Add(field.Name);
}
else
{
structureExpression.AddError("Cannot evaluate value for " + pair.Value, RuleChecksEnum.ExecutionFailed);
}
}
else
{
structureExpression.AddError("Cannot find structure element " + pair.Key.Image, RuleChecksEnum.ExecutionFailed);
}
}
foreach (StructureElement element in Structure.Elements)
{
if (!members.Contains(element.Name))
{
Field field = CreateField(element, structureExpression.RootLog);
field.Value = element.DefaultValue;
}
}
}
finally
{
_depth -= 1;
}
}
/// <summary>
/// Browses through the expression to find the value to edit
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
private Expression VisitExpression(Expression expression)
{
Expression retVal = expression;
BinaryExpression binaryExpression = expression as BinaryExpression;
if (binaryExpression != null)
{
binaryExpression.Left = VisitExpression(binaryExpression.Left);
binaryExpression.Right = VisitExpression(binaryExpression.Right);
}
UnaryExpression unaryExpression = expression as UnaryExpression;
if (unaryExpression != null)
{
if (unaryExpression.Expression != null)
{
unaryExpression.Expression = VisitExpression(unaryExpression.Expression);
}
else if (unaryExpression.Term != null)
{
VisitTerm(unaryExpression.Term);
}
}
StructExpression structExpression = expression as StructExpression;
if (structExpression != null)
{
retVal = EditExpression(structExpression);
}
Call call = expression as Call;
if (call != null)
{
foreach (Expression subExpression in call.AllParameters)
{
VisitExpression(subExpression);
}
}
return(retVal);
}
public void EvaluatesBasicExpressionWithConstantAndParameter()
{
using var inputParams = new NativeArray <float>(new float[] { 2f }, Allocator.Persistent);
using var operatorData = new NativeArray <OperatorDefinition>(new OperatorDefinition[]
{
new OperatorDefinition
{
operatorType = OperatorType.MULTIPLY,
rhs = 1,
lhs = 2
},
new OperatorDefinition
{
operatorType = OperatorType.CONSTANT_VALUE,
nodeValue = 1.5f
},
new OperatorDefinition
{
operatorType = OperatorType.PARAMETER_VALUE,
parameterIndex = 0
},
}, Allocator.Persistent);
var expression = new StructExpression
{
operationDataSlice = new JaggedIndexing
{
index = 0,
length = 3
}
};
var result = expression.EvaluateExpression(
inputParams,
new JaggedIndexing
{
index = 0,
length = 1
},
operatorData);
Assert.AreEqual(3f, result);
}
/// <summary>
/// Splits the selected action to several sub-actions
/// </summary>
public virtual void SplitHandler(object sender, EventArgs args)
{
Statement statement = new Parser().Statement(Item, Item.ExpressionText);
VariableUpdateStatement variableUpdateStatement = statement as VariableUpdateStatement;
if (variableUpdateStatement != null)
{
Expression expression = variableUpdateStatement.Expression;
StructExpression structExpression = expression as StructExpression;
if (structExpression != null)
{
Dictionary <Designator, Expression> associations = structExpression.Associations;
foreach (KeyValuePair <Designator, Expression> value in associations)
{
Action action = (Action)acceptor.getFactory().createAction();
action.ExpressionText = structExpression.Structure + "." + value.Key + " <- " +
value.Value;
ActionTreeNode actionTreeNode = new ActionTreeNode(action, true);
BaseTreeNode parent = Parent as BaseTreeNode;
if (parent != null)
{
RuleCondition ruleCondition = Item.Enclosing as RuleCondition;
if (ruleCondition != null)
{
ruleCondition.appendActions(action);
}
else
{
SubStep subStep = Item.Enclosing as SubStep;
if (subStep != null)
{
subStep.appendActions(action);
}
}
parent.Nodes.Add(actionTreeNode);
}
}
}
}
Delete();
}
public float DynamicInvoke(params float[] input)
{
using var inputParams = new NativeArray <float>(input, Allocator.Temp);
using var opDefs = new NativeArray <OperatorDefinition>(definitionList.ToArray(), Allocator.Temp);
var structExp = new StructExpression
{
operationDataSlice = new JaggedIndexing
{
index = 0,
length = (ushort)opDefs.Length
}
};
return(structExp.EvaluateExpression(
inputParams,
new JaggedIndexing
{
index = 0,
length = (ushort)inputParams.Length
},
opDefs));
}
protected override void VisitStructExpression(StructExpression structExpression)
{
if (structExpression.Structure != null)
{
VisitExpression(structExpression.Structure);
}
ModelElement backup = BaseLocation;
BaseLocation = structExpression.Structure.GetExpressionType();
foreach (KeyValuePair <Designator, Expression> pair in structExpression.Associations)
{
if (pair.Key != null)
{
VisitDesignator(pair.Key);
}
if (pair.Value != null)
{
VisitExpression(pair.Value);
}
}
BaseLocation = backup;
}
public void WriteDataIntoMemory(
SystemLevelRuleNativeData dataArray,
SymbolSeriesMatcherNativeDataWriter dataWriter)
{
ContextSuffix = forwardsMatchBuilder.BuildIntoManagedMemory(dataArray, dataWriter);
ContextPrefix = backwardsMatchBuilder.BuildIntoManagedMemory(dataArray, dataWriter);
foreach (var outcome in possibleOutcomes)
{
outcome.WriteIntoMemory(dataArray, dataWriter);
}
possibleOutcomeIndexing = new JaggedIndexing
{
index = dataWriter.indexInRuleOutcomes,
length = (ushort)possibleOutcomes.Length
};
for (int i = 0; i < possibleOutcomeIndexing.length; i++)
{
var possibleOutcome = possibleOutcomes[i];
dataArray.ruleOutcomeMemorySpace[i + dataWriter.indexInRuleOutcomes] = possibleOutcome.AsBlittable();
}
dataWriter.indexInRuleOutcomes += possibleOutcomeIndexing.length;
if (conditionalChecker != null)
{
var opSize = conditionalChecker.OperatorSpaceNeeded;
conditionalCheckerBlittable = conditionalChecker.WriteIntoOpDataArray(
dataArray.dynamicOperatorMemory,
new JaggedIndexing
{
index = dataWriter.indexInOperatorMemory,
length = opSize
});
dataWriter.indexInOperatorMemory += opSize;
}
}
static void SemanticsProcessor(StringBuilder stringBuilder, ShaderMetadata metadata)
{
if (metadata.Semantics == null)
{
return;
}
for (int i = 0; i < metadata.Semantics.Count; i++)
{
// Get
StructExpression item = metadata.Semantics[i];
// Write type
stringBuilder.Append("struct");
// Write name
stringBuilder.Append(" ");
stringBuilder.Append(item.ConstituentSymbols[1].ToString());
// Begin
stringBuilder.Append(Environment.NewLine);
stringBuilder.Append("{");
stringBuilder.Append(Environment.NewLine);
// Get struct statement block
StructStatementBlockExpression block = item.ConstituentSymbols.Find(s => s is StructStatementBlockExpression) as StructStatementBlockExpression;
if (block == null)
{
throw new ArgumentNullException("block");
}
// Write statement
for (int j = 0; j < block.ConstituentSymbols.Count; j++)
{
StructStatementExpression statement = block.ConstituentSymbols[j] as StructStatementExpression;
// Write tab
stringBuilder.Append("\t");
// Write type
stringBuilder.Append(statement.ConstituentSymbols[0].ToString());
// Write name
stringBuilder.Append(" ");
stringBuilder.Append(statement.ConstituentSymbols[1].ToString());
// Write double dot
stringBuilder.Append(" :");
// Write semantic
stringBuilder.Append(" ");
string semantic = statement.ConstituentSymbols[3].ToString();
int index = metadata.Semantics.IndexOf(item);
if (metadata is VertexShaderMetadata)
{
if (metadata.Semantics.IndexOf(item) == 1 && semantic.StartsWith("POSITION", StringComparison.InvariantCulture))
{
semantic = semantic.Replace("POSITION", "SV_POSITION");
}
}
else if (metadata is PixelShaderMetadata)
{
if (index == 0 && semantic.StartsWith("POSITION", StringComparison.InvariantCulture))
{
semantic = semantic.Replace("POSITION", "SV_POSITION");
}
else if (index == 1 && semantic.StartsWith("COLOR", StringComparison.InvariantCulture))
{
semantic = semantic.Replace("COLOR", "SV_TARGET");
}
else if (index == 1 && semantic.StartsWith("DEPTH", StringComparison.InvariantCulture))
{
semantic = semantic.Replace("DEPTH", "SV_DEPTH");
}
}
stringBuilder.Append(semantic);
// Finalize
stringBuilder.Append(";");
stringBuilder.Append(Environment.NewLine);
}
// End
stringBuilder.Append("};");
stringBuilder.Append(Environment.NewLine);
}
}
/// <summary>
/// Visits a struct expression
/// </summary>
/// <param name="structExpression"></param>
protected override void VisitStructExpression(StructExpression structExpression)
{
ModelElement backup = User;
Structure structure = null;
if (structExpression.Structure != null)
{
structure = structExpression.Structure.GetExpressionType() as Structure;
VisitExpression(structExpression.Structure);
}
foreach (KeyValuePair<Designator, Expression> pair in structExpression.Associations)
{
ResetRemoveIndexes();
if (pair.Key != null)
{
User = structure;
VisitDesignator(pair.Key);
User = backup;
}
ResetRemoveIndexes();
if (pair.Value != null)
{
VisitExpression(pair.Value);
}
}
}
public object Visit(StructExpression node)
{
return(null);
}
protected override void VisitStructExpression(StructExpression structExpression)
{
if (structExpression.Structure != null)
{
VisitExpression(structExpression.Structure);
}
ModelElement backup = BaseLocation;
BaseLocation = structExpression.Structure.GetExpressionType();
foreach (KeyValuePair<Designator, Expression> pair in structExpression.Associations)
{
if (pair.Key != null)
{
VisitDesignator(pair.Key);
}
if (pair.Value != null)
{
VisitExpression(pair.Value);
}
}
BaseLocation = backup;
}
public object Visit(StructExpression node)
{
throw new System.NotImplementedException();
}
