public void Setup()
{
_options = Options.Create();
_source = new ValueNode(
new Context(_options, Mode.Deserialize, "json"), null,
new SimpleValue(typeof(int?).ToCachedType()), null, null);
_target = new ValueNode(
new Context(_options, Mode.Deserialize, "json"), null,
new SimpleValue(typeof(int?).ToCachedType()), null, null);
_readers = new ReaderConventions(_options);
_visitorIncrement = (s, t, o) =>
{
should_have_valid_parameters(s, t, o);
t.Value = t.Value == null ? 1 : (int?)t.Value + 1;
};
_readerIncrement = (s, t, o) =>
{
should_have_valid_parameters(s, t, o);
t.Value = t.Value == null ? 1 : (int?)t.Value + 1;
};
_readerIncrementValue = (v, s, t, o) =>
{
should_have_valid_parameters(v, s, t, o);
return s.Value == null ? 1 : (int)s.Value + 1;
};
_readerIncrementNullableValue = (v, s, t, o) =>
{
should_have_valid_parameters(v, s, t, o);
return s.Value == null ? 1 : (int?)s.Value + 1;
};
}
public static Instruction CreateBinaryInstruction(
string mnemonic, OperationNode op, int exUnit,
ValueNode vres, RegisterSet vresRegs,
ValueNode v1, RegisterSet v1Regs,
ValueNode v2, RegisterSet v2Regs)
{
InstructionPattern ip = new InstructionPattern();
ip.AddNode(op);
ip.AddNode(vres);
ip.AddNode(v1);
ip.AddNode(v2);
ip.AddEdge(op, vres);
ip.AddEdge(v1, op);
ip.AddEdge(v2, op);
ip.OperandValues.Add(v1);
ip.OperandValues.Add(v2);
ip.ResultValue = vres;
Instruction i = new Instruction(mnemonic, ip);
i.ExecutionUnit = exUnit;
i.ResultRegisters = vresRegs;
i.OperandsRegisters[0] = v1Regs;
i.OperandsRegisters[1] = v2Regs;
return i;
}
public FarmDataRoot(BlockNode.BLOCK_NAME block_name, BufferNode.BUFFER_NAME buffer_name)
{
Guid = Guid.NewGuid();
Block = new BlockNode(block_name);
Buffer = new BufferNode(buffer_name);
TempValueNode = new ValueNode();
}
public FarmDataRoot()
{
Guid = Guid.NewGuid();
Block = new BlockNode();
Buffer = new BufferNode();
TempValueNode = new ValueNode();
}
protected void CreateSingleLoop(
ProgramGraph g, ValueNode ap, ValueNode bp, ValueNode s,
ValueNode ap1, ValueNode bp1, ValueNode s1)
{
OperationNode[] o = new OperationNode[8];
o[0] = new AddOperationNode();
o[1] = new MulOperationNode();
o[2] = new LoadOperationNode();
o[3] = new AddOperationNode();
o[4] = new LoadOperationNode();
o[5] = new AddOperationNode();
o[6] = new ConstOperationNode();
o[7] = new ConstOperationNode();
foreach (OperationNode op in o)
g.AddNode(op);
ValueNode[] v = new ValueNode[7];
v[0] = new FloatRegisterNode();
v[1] = new FloatRegisterNode();
v[2] = new FloatRegisterNode();
v[3] = new IntRegisterNode();
v[4] = new IntRegisterNode();
v[5] = new IntConstantNode(4);
v[6] = new IntConstantNode(4);
foreach (ValueNode val in v)
g.AddNode(val);
g.AddEdge(v[0], o[0]);
g.AddEdge(s, o[0]);
g.AddEdge(o[0], s1);
g.AddEdge(v[1], o[1]);
g.AddEdge(v[2], o[1]);
g.AddEdge(o[1], v[0]);
g.AddEdge(ap, o[2]);
g.AddEdge(o[2], v[1]);
g.AddEdge(ap, o[3]);
g.AddEdge(v[3], o[3]);
g.AddEdge(o[3], ap1);
g.AddEdge(bp, o[4]);
g.AddEdge(o[4], v[2]);
g.AddEdge(bp, o[5]);
g.AddEdge(v[4], o[5]);
g.AddEdge(o[5], bp1);
g.AddEdge(v[5], o[6]);
g.AddEdge(o[6], v[3]);
g.AddEdge(v[6], o[7]);
g.AddEdge(o[7], v[4]);
}
public ProgramGraph CreateUnrolledProgramGraph(int k)
{
ProgramGraph g = new ProgramGraph();
ValueNode[] ap = new ValueNode[k + 1];
ValueNode[] bp = new ValueNode[k + 1];
ValueNode[] cp = new ValueNode[k + 1];
for (int i = 0; i < k + 1; i++) {
ap[i] = new TestRegisterNode("a[" + i + "]", Datatype.AddressValue);
bp[i] = new TestRegisterNode("b[" + i + "]", Datatype.AddressValue);
cp[i] = new TestRegisterNode("c[" + i + "]", Datatype.AddressValue);
g.AddNode(ap[i]);
g.AddNode(bp[i]);
g.AddNode(cp[i]);
}
ValueNode k0 = new TestRegisterNode("k0", Datatype.FloatValue);
ValueNode k1 = new TestRegisterNode("k1", Datatype.FloatValue);
g.AddNode(k0);
g.AddNode(k1);
for (int i = 0; i < k; i++) {
CreateSingleLoop(
g, ap[i], bp[i], cp[i], k0, k1,
ap[i + 1], bp[i + 1], cp[i + 1]);
}
g.InitInputValues();
g.InitOutputValues();
g.OutputValues.Add(k0);
g.OutputValues.Add(k1);
g.CyclicDependencies[ap[0]] = ap[k];
g.CyclicDependencies[ap[k]] = ap[0];
g.CyclicDependencies[bp[0]] = bp[k];
g.CyclicDependencies[bp[k]] = bp[0];
g.CyclicDependencies[cp[0]] = cp[k];
g.CyclicDependencies[cp[k]] = cp[0];
return g;
}
public void Setup()
{
_options = Options.Create();
_source = new ValueNode(
new Context(_options, Mode.Deserialize, "object"), null,
new SimpleValue(typeof(int?).ToCachedType()), null, null);
_target = new Node("yada") { NodeType = NodeType.Value, Format = "xml", Type = "element" };
_writers = new WriterConventions(_options);
_visitorIncrement = (s, t, o) =>
{
should_have_valid_parameters(s, t, o);
t.Value = t.Value == null ? 1 : (int?)t.Value + 1;
};
_writerObjectIncrement = (v, s, t, o) =>
{
should_have_valid_parameters(s, t, o);
t.Value = (int?) t.Value + 1 ?? 1;
};
_writerIncrement = (v, s, t, o) =>
{
should_have_valid_parameters(s, t, o);
t.Value = (int?) t.Value + 1 ?? 1;
};
_writerNullableIncrement = (v, s, t, o) =>
{
should_have_valid_parameters(s, t, o);
t.Value = t.Value == null ? 1 : (int?)t.Value + 1;
};
_writerIncrementValue = (v, s, t, o) =>
{
should_have_valid_parameters(s, t, o);
return v + 1;
};
_writerIncrementNullableValue = (v, s, t, o) =>
{
should_have_valid_parameters(s, t, o);
return v == null ? 1 : v + 1;
};
}
// Use this for initialization
void Start()
{
Patch p = new Patch();
ValueNode<float> v1 = new ValueNode<float>();
p.AddNode(v1);
v1.Output.Value = 15;
v2 = new ValueNode<float>();
p.AddNode(v2);
AddNode sum = new AddNode();
p.AddNode(sum);
p.Connect(v1.Output, sum.A);
p.Connect(v2.Output, sum.B);
patchEvaluator = new PatchEvaluator(p);
patchEvaluator.Evaluate();
}
public static Instruction CreateLeftTernaryInstruction(
string mnemonic, OperationNode op1, OperationNode op2, int exUnit,
ValueNode vres, RegisterSet vresRegs,
ValueNode v1, RegisterSet v1Regs,
ValueNode v2, RegisterSet v2Regs,
ValueNode v3, RegisterSet v3Regs)
{
InstructionPattern ip = new InstructionPattern();
ip.AddNode(op1);
ip.AddNode(op2);
ip.AddNode(vres);
ip.AddNode(v1);
ip.AddNode(v2);
ip.AddNode(v3);
ValueNode iv1 = new RegisterValueNode(v1.Datatype);
ip.AddNode(iv1);
ip.AddEdge(v1, op1);
ip.AddEdge(v2, op1);
ip.AddEdge(op1, iv1);
ip.AddEdge(iv1, op2);
ip.AddEdge(v3, op2);
ip.AddEdge(op2, vres);
ip.OperandValues.Add(v1);
ip.OperandValues.Add(v2);
ip.OperandValues.Add(v3);
ip.ResultValue = vres;
Instruction i = new Instruction(mnemonic, ip);
i.ExecutionUnit = exUnit;
i.ResultRegisters = vresRegs;
i.OperandsRegisters[0] = v1Regs;
i.OperandsRegisters[1] = v2Regs;
i.OperandsRegisters[2] = v3Regs;
return i;
}
private void DoCalculateData()
{
_ratingsByUser = _commonData.AllRatings.ToLookup(key => key.User);
var variance = new List<Tuple<KeyNode, ValueNode>>();
foreach (var combo in GetAllTwoMovieCombinations())
{
var valuesForKeyByMovie3 = GetAllKeyedValues(combo).ToLookup(key => key.Movie3);
foreach (var v in valuesForKeyByMovie3)
{
double score1 = v.Average(x => x.Rating1);
double score2 = v.Average(x => x.Rating2);
double score3 = v.Average(x => x.Rating3);
var meanValueNode = new ValueNode(score1, score2, v.Key, score3);
variance.Add(Tuple.Create(combo, meanValueNode));
}
}
_variance = variance.ToLookup(key => key.Item1, val => val.Item2);
}
public ProgramGraph CreateUnrolledProgramGraph(int k) {
ProgramGraph g = new ProgramGraph();
ValueNode[] ap = new ValueNode[k + 1];
ValueNode[] bp = new ValueNode[k + 1];
ValueNode[] s = new ValueNode[k + 1];
for (int i = 0; i < k + 1; i++) {
ap[i] = new TestRegisterNode("a[" + i + "]", Datatype.AddressValue);
bp[i] = new TestRegisterNode("b[" + i + "]", Datatype.AddressValue);
s[i] = new TestRegisterNode("s[" + i + "]", Datatype.FloatValue);
g.AddNode(ap[i]);
g.AddNode(bp[i]);
g.AddNode(s[i]);
}
for (int i = 0; i < k; i++)
CreateSingleLoop(
g, ap[i], bp[i], s[i], ap[i + 1], bp[i + 1], s[i + 1]);
}
public void SetUp()
{
nodeList = new MasterNodeList<string>();
vn = nodeList.newValueNodeFromValue("A");
vn2 = nodeList.newValueNodeFromValue("B");
vn3 = nodeList.newValueNodeFromValue("C");
edge = new Edge() {
link = new DirectedPair()
{
from = vn,
to = vn2
}
};
edge2 = new Edge()
{
link = new DirectedPair()
{
from = vn3,
to = vn
}
};
routeFactory = new RouteFactory<string>();
routeFactory.newRouteFromEdge(edge);
}
public void should_add_value_reader_and_fail_read_with_value_reader_exception_when_friendly_error_does_not_exist()
{
_source.Value = 0;
var target = new ValueNode(
new Context(_options, Mode.Deserialize, "json"), null,
new SimpleValue(typeof(Tuple<string>).ToCachedType()), null, null);
var exception = new Exception();
_readers.AddValueReader<Tuple<string>>((v, s, t, o) => { throw exception; }, (v, s, t, o) => true);
Assert.DoesNotThrow(() => _readers.Mapping.HasMapping(_source, target));
Assert.Throws<ReaderException>(() => _readers
.Mapping.Map(_source, target))
.InnerException.ShouldBeSameAs(exception);
}
public void Visit(ElementNode node, INode parentNode)
{
var typeref = Module.ImportReference(node.XmlType.GetTypeReference(Module, node));
TypeDefinition typedef = typeref.ResolveCached();
if (IsXaml2009LanguagePrimitive(node))
{
var vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(PushValueFromLanguagePrimitive(typedef, node));
Context.IL.Emit(OpCodes.Stloc, vardef);
return;
}
//if this is a MarkupExtension that can be compiled directly, compile and returns the value
var compiledMarkupExtensionName = typeref.GetCustomAttribute(Module.ImportReferenceCached(typeof(ProvideCompiledAttribute)))?.ConstructorArguments?[0].Value as string;
Type compiledMarkupExtensionType;
ICompiledMarkupExtension markupProvider;
if (compiledMarkupExtensionName != null &&
(compiledMarkupExtensionType = Type.GetType(compiledMarkupExtensionName)) != null &&
(markupProvider = Activator.CreateInstance(compiledMarkupExtensionType) as ICompiledMarkupExtension) != null)
{
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
typeref = Module.ImportReference(typeref);
var vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
foreach (var prop in node.Properties)
{
if (!node.SkipProperties.Contains(prop.Key))
{
node.SkipProperties.Add(prop.Key);
}
}
node.CollectionItems.Clear();
return;
}
MethodDefinition factoryCtorInfo = null;
MethodDefinition factoryMethodInfo = null;
MethodDefinition parameterizedCtorInfo = null;
MethodDefinition ctorInfo = null;
if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryCtorInfo == null)
{
throw new XamlParseException(
string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node);
}
ctorInfo = factoryCtorInfo;
if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params
{
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
}
}
else if (node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
var factoryMethod = (string)(node.Properties [XmlName.xFactoryMethod] as ValueNode).Value;
factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryMethodInfo == null)
{
throw new XamlParseException(
String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node);
}
Context.IL.Append(PushCtorXArguments(factoryMethodInfo, node));
}
if (ctorInfo == null && factoryMethodInfo == null)
{
parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.Parameters.All(
pd =>
pd.CustomAttributes.Any(
ca =>
ca.AttributeType.FullName ==
"Xamarin.Forms.ParameterAttribute")));
}
if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node))
{
ctorInfo = parameterizedCtorInfo;
// IL_0000: ldstr "foo"
Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node));
}
ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic);
var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module);
var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module);
var implicitOperatorref = typedef.Methods.FirstOrDefault(md =>
md.IsPublic &&
md.IsStatic &&
md.IsSpecialName &&
md.Name == "op_Implicit" && md.Parameters [0].ParameterType.FullName == "System.String");
if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType)
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
ValueNode vnode = null;
if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
vardef.VariableType.IsValueType)
{
//<Color>Purple</Color>
Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider [] { typedef },
node.PushServiceProvider(Context), false, true));
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
implicitOperatorref != null)
{
//<FileImageSource>path.png</FileImageSource>
var implicitOperator = Module.ImportReference(implicitOperatorref);
Context.IL.Emit(OpCodes.Ldstr, ((ValueNode)(node.CollectionItems.First())).Value as string);
Context.IL.Emit(OpCodes.Call, implicitOperator);
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (factorymethodinforef != null)
{
Context.IL.Emit(OpCodes.Call, Module.ImportReference(factorymethodinforef));
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (!typedef.IsValueType)
{
var ctor = Module.ImportReference(ctorinforef);
// IL_0001: newobj instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::'.ctor'()
// IL_0006: stloc.0
Context.IL.Emit(OpCodes.Newobj, ctor);
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) &&
!node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, typeref, Module, Context))
{
// IL_0008: ldloca.s 1
// IL_000a: ldc.i4.1
// IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool)
var ctor = Module.ImportReference(ctorinforef);
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
Context.IL.Emit(OpCodes.Call, ctor);
}
else
{
// IL_0000: ldloca.s 0
// IL_0002: initobj Test/Foo
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Emit(OpCodes.Initobj, Module.ImportReference(typedef));
}
if (typeref.FullName == "Xamarin.Forms.Xaml.ArrayExtension")
{
var visitor = new SetPropertiesVisitor(Context);
foreach (var cnode in node.Properties.Values.ToList())
{
cnode.Accept(visitor, node);
}
foreach (var cnode in node.CollectionItems)
{
cnode.Accept(visitor, node);
}
markupProvider = new ArrayExtension();
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
foreach (var prop in node.Properties)
{
if (!node.SkipProperties.Contains(prop.Key))
{
node.SkipProperties.Add(prop.Key);
}
}
node.CollectionItems.Clear();
return;
}
}
}
protected void CreateSingleLoop(
ProgramGraph g, ValueNode ap, ValueNode bp, ValueNode cp,
ValueNode k0, ValueNode k1,
ValueNode ap1, ValueNode bp1, ValueNode cp1)
{
OperationNode[] o = new OperationNode[12];
o[0] = new AddOperationNode();
o[1] = new MulOperationNode();
o[2] = new MulOperationNode();
o[3] = new LoadOperationNode();
o[4] = new AddOperationNode();
o[5] = new LoadOperationNode();
o[6] = new AddOperationNode();
o[7] = new ConstOperationNode();
o[8] = new ConstOperationNode();
o[9] = new StoreOperationNode();
o[10] = new AddOperationNode();
o[11] = new ConstOperationNode();
foreach (OperationNode op in o)
g.AddNode(op);
ValueNode[] v = new ValueNode[12];
v[0] = new FloatRegisterNode();
v[1] = new FloatRegisterNode();
v[2] = new FloatRegisterNode();
v[3] = new FloatRegisterNode();
v[4] = new IntRegisterNode();
v[5] = new IntRegisterNode();
v[6] = new IntConstantNode(4);
v[7] = new IntConstantNode(4);
v[8] = new FloatRegisterNode();
v[9] = new FloatMemoryNode(null);
v[10] = new IntRegisterNode();
v[11] = new IntConstantNode(4);
foreach (ValueNode val in v)
g.AddNode(val);
g.AddEdge(v[0], o[0]);
g.AddEdge(v[1], o[0]);
g.AddEdge(o[0], v[8]);
g.AddEdge(v[2], o[1]);
g.AddEdge(k0, o[1]);
g.AddEdge(o[1], v[0]);
g.AddEdge(v[3], o[2]);
g.AddEdge(k1, o[2]);
g.AddEdge(o[2], v[1]);
g.AddEdge(ap, o[3]);
g.AddEdge(o[3], v[2]);
g.AddEdge(ap, o[4]);
g.AddEdge(v[4], o[4]);
g.AddEdge(o[4], ap1);
g.AddEdge(bp, o[5]);
g.AddEdge(o[5], v[3]);
g.AddEdge(bp, o[6]);
g.AddEdge(v[5], o[6]);
g.AddEdge(o[6], bp1);
g.AddEdge(v[6], o[7]);
g.AddEdge(o[7], v[4]);
g.AddEdge(v[7], o[8]);
g.AddEdge(o[8], v[5]);
g.AddEdge(v[8], o[9]);
g.AddEdge(cp, o[9]);
g.AddEdge(o[9], v[9]);
g.AddEdge(cp, o[10]);
g.AddEdge(v[10], o[10]);
g.AddEdge(o[10], cp1);
g.AddEdge(v[11], o[11]);
g.AddEdge(o[11], v[10]);
}
public ValueNode(ValueNode node)
{
Value = node.Value;
Name = Value.ToString();
}
public override ValueNode CreateSerializerOverride(ValueNode parent)
{
return(new UnknownValueNode(parent, Name, this));
}
public ProgramGraph CreateUnrolledProgramGraph(int k)
{
ProgramGraph g = new ProgramGraph();
ValueNode[] px = new ValueNode[k + 1];
ValueNode[] py = new ValueNode[k + 1];
for (int i = 0; i < k + 1; i++) {
px[i] = new TestRegisterNode("x[" + i + "]", Datatype.AddressValue);
py[i] = new TestRegisterNode("y[" + i + "]", Datatype.AddressValue);
g.AddNode(px[i]);
g.AddNode(py[i]);
}
ValueNode[] x = new ValueNode[k];
ValueNode[] y = new ValueNode[k];
for (int i = 0; i < k; i++) {
x[i] = new FloatRegisterNode();
y[i] = new FloatRegisterNode();
g.AddNode(x[i]);
g.AddNode(y[i]);
}
ValueNode[] x0 = new ValueNode[k + 1];
ValueNode[] x1 = new ValueNode[k + 1];
for (int i = 0; i < k + 1; i++) {
x0[i] = new TestRegisterNode("x0[" + i + "]", Datatype.FloatValue);
x1[i] = new TestRegisterNode("x1[" + i + "]", Datatype.FloatValue);
g.AddNode(x0[i]);
g.AddNode(x1[i]);
}
ValueNode pc0 = new FloatMemoryNode("c0");
ValueNode pc1 = new FloatMemoryNode("c1");
ValueNode pc2 = new FloatMemoryNode("c2");
ValueNode pc3 = new FloatMemoryNode("c3");
ValueNode pc4 = new FloatMemoryNode("c4");
OperationNode lc0 = new LoadOperationNode();
OperationNode lc1 = new LoadOperationNode();
OperationNode lc2 = new LoadOperationNode();
OperationNode lc3 = new LoadOperationNode();
OperationNode lc4 = new LoadOperationNode();
ValueNode c0 = new FloatRegisterNode();
ValueNode c1 = new FloatRegisterNode();
ValueNode c2 = new FloatRegisterNode();
ValueNode c3 = new FloatRegisterNode();
ValueNode c4 = new FloatRegisterNode();
g.AddNode(pc0); g.AddNode(pc1); g.AddNode(pc2);
g.AddNode(pc3); g.AddNode(pc4);
g.AddNode(lc0); g.AddNode(lc1); g.AddNode(lc2);
g.AddNode(lc3); g.AddNode(lc4);
g.AddNode(c0); g.AddNode(c1); g.AddNode(c2);
g.AddNode(c3); g.AddNode(c4);
g.AddEdge(pc0, lc0); g.AddEdge(lc0, c0);
g.AddEdge(pc1, lc1); g.AddEdge(lc1, c1);
g.AddEdge(pc2, lc2); g.AddEdge(lc2, c2);
g.AddEdge(pc3, lc3); g.AddEdge(lc3, c3);
g.AddEdge(pc4, lc4); g.AddEdge(lc4, c4);
for (int i = 0; i < k; i++) {
CreateLoadIncGraph(
g, x[i], px[i], px[i + 1], 4);
CreateStoreIncGraph(
g, y[i], py[i], py[i + 1], 4);
CreateSingleFilterLoop(
g, x[i], x0[i], x1[i], c0, c1, c2, c3, c4,
x0[i + 1], x1[i + 1], y[i]);
}
g.InitInputValues();
g.InitOutputValues();
g.CyclicDependencies[x0[0]] = x0[k];
g.CyclicDependencies[x0[k]] = x0[0];
g.CyclicDependencies[x1[0]] = x1[k];
g.CyclicDependencies[x1[k]] = x1[0];
g.CyclicDependencies[px[0]] = px[k];
g.CyclicDependencies[px[k]] = px[0];
g.CyclicDependencies[py[0]] = py[k];
g.CyclicDependencies[py[k]] = py[0];
return g;
}
protected void CreateSingleLoop(
ProgramGraph g, ValueNode xp, ValueNode yp, ValueNode x, ValueNode y,
ValueNode c0, ValueNode c1, ValueNode c2, ValueNode xp1, ValueNode yp1,
ValueNode x1, ValueNode y1)
{
OperationNode[] o = new OperationNode[11];
o[0] = new StoreOperationNode();
o[1] = new AddOperationNode();
o[2] = new AddOperationNode();
o[3] = new ConstOperationNode();
o[4] = new AddOperationNode();
o[5] = new MulOperationNode();
o[6] = new MulOperationNode();
o[7] = new MulOperationNode();
o[8] = new LoadOperationNode();
o[9] = new AddOperationNode();
o[10] = new ConstOperationNode();
foreach (OperationNode op in o)
g.AddNode(op);
ValueNode[] v = new ValueNode[9];
v[0] = new FloatMemoryNode(null);
v[1] = new IntRegisterNode();
v[2] = new FloatRegisterNode();
v[3] = new FloatRegisterNode();
v[4] = new IntConstantNode(4);
v[5] = new FloatRegisterNode();
v[6] = new FloatRegisterNode();
v[7] = new IntRegisterNode();
v[8] = new IntConstantNode(4);
foreach (ValueNode val in v)
g.AddNode(val);
g.AddEdge(y1, o[0]);
g.AddEdge(yp, o[0]);
g.AddEdge(o[0], v[0]);
g.AddEdge(yp, o[1]);
g.AddEdge(v[1], o[1]);
g.AddEdge(o[1], yp1);
g.AddEdge(v[2], o[2]);
g.AddEdge(v[3], o[2]);
g.AddEdge(o[2], y1);
g.AddEdge(v[4], o[3]);
g.AddEdge(o[3], v[1]);
g.AddEdge(v[5], o[4]);
g.AddEdge(v[6], o[4]);
g.AddEdge(o[4], v[2]);
g.AddEdge(c2, o[5]);
g.AddEdge(y, o[5]);
g.AddEdge(o[5], v[3]);
g.AddEdge(c1, o[6]);
g.AddEdge(x, o[6]);
g.AddEdge(o[6], v[5]);
g.AddEdge(c0, o[7]);
g.AddEdge(x1, o[7]);
g.AddEdge(o[7], v[6]);
g.AddEdge(xp, o[8]);
g.AddEdge(o[8], x1);
g.AddEdge(xp, o[9]);
g.AddEdge(v[7], o[9]);
g.AddEdge(o[9], xp1);
g.AddEdge(v[8], o[10]);
g.AddEdge(o[10], v[7]);
}
public object GetBoundValue(ValueNode target)
{
return(GetValue(binding => binding.GetBoundValue(target)));
}
public void WriteName(ITextColorWriter output, ValueNode vm) => vm.CachedName.WriteTo(output);
public void CreateValueNode()
{
ValueNode field = factory.CreateValueNode("Value", ValueNodeType.Text);
Assert.IsNotNull(field);
}
public void CreateValueNode_FromString()
{
ValueNode field = factory.CreateValueNode("Value", "Text");
Assert.IsNotNull(field);
}
private static TomlObject ToTomlValue(ITomlRoot root, ValueNode node)
{
switch (node.Value.SyntaxNode())
{
case TerminalNode tn: return(CreateValueFromTerminal(tn.Terminal));
case ArrayNode an: return(CreateArrayOrTableArray(an));
case InlineTableNode it: return(CreateInlineTable(it));
default: throw new Exception($"Cannot create TomlValue from node with type '{node.GetType()}'.");
}
TomlValue CreateValueFromTerminal(Token terminal)
{
switch (terminal.Type)
{
case TokenType.Integer: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 0)), TomlInt.IntTypes.Decimal));
case TokenType.HexInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 16), TomlInt.IntTypes.Hex));
case TokenType.BinaryInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 2), TomlInt.IntTypes.Binary));
case TokenType.OctalInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 8), TomlInt.IntTypes.Octal));
case TokenType.Bool: return(new TomlBool(root, Convert.ToBoolean(terminal.Value)));
case TokenType.String: return(new TomlString(root, terminal.Value.Unescape(terminal)));
case TokenType.LiteralString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.Literal));
case TokenType.MultilineLiteralString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.MultilineLiteral));
case TokenType.MultilineString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.Multiline));
case TokenType.Float: return(TomlFloat.FromTerminal(root, terminal));
case TokenType.OffsetDateTime: return(TomlOffsetDateTime.Parse(root, terminal.Value));
case TokenType.LocalTime: return(TomlLocalTime.Parse(root, terminal.Value));
case TokenType.Duration: return(TomlDuration.Parse(root, terminal.Value));
case TokenType.LocalDate: return(TomlLocalDate.Parse(root, terminal.Value));
case TokenType.LocalDateTime: return(TomlLocalDateTime.Parse(root, terminal.Value));
default: throw new NotSupportedException();
}
string Cleanup(string s, int sub)
=> s.Substring(sub).Replace("_", string.Empty);
}
TomlObject CreateArrayOrTableArray(ArrayNode array)
{
var values = CreateValues(array.GetValues()).ToList();
var tables = values.OfType <TomlTable>().ToList();
if (tables.Count > 0 && tables.Count == values.Count)
{
var ta = new TomlTableArray(root, tables);
ta.AddComments(array);
return(ta);
}
else if (tables.Count == 0)
{
var arr = new TomlArray(root, values.Cast <TomlValue>().ToArray());
arr.AddComments(array);
return(arr);
}
else
{
throw new InvalidOperationException("Array is a mixture of a value array and a TOML table array.");
}
IEnumerable <TomlObject> CreateValues(IEnumerable <ValueNode> nodes)
{
var linked = nodes.Select(n => Tuple.Create(n, ToTomlValue(root, n))).ToList();
var expectedType = linked.DistinctBy(n => n.Item2.GetType()).FirstOrDefault();
var wrongType = linked.DistinctBy(n => n.Item2.GetType()).Skip(1).FirstOrDefault();
if (wrongType != null)
{
string msg = $"Expected array value of type '{expectedType.Item2.ReadableTypeName}' " +
$"but value of type '{wrongType.Item2.ReadableTypeName}' was found.'";
throw ParseException.MessageForNode(wrongType.Item1, msg);
}
return(linked.Select(l => l.Item2));
}
}
TomlTable CreateInlineTable(InlineTableNode it)
{
TomlTable table = new TomlTable(root, TomlTable.TableTypes.Inline);
table.AddComments(it);
System.Collections.Generic.IEnumerable <KeyValueExpressionNode> expressions = it.GetExpressions();
foreach (KeyValueExpressionNode e in expressions)
{
table.AddRow(e.Key.SyntaxNode().ExpressionKey(), ToTomlValue(root, e.Value.SyntaxNode()));
}
return(table);
}
}
public static void UnbundleEvent(Node node)
{
EventNode eNode = node.Control as EventNode;
List <Relation> deleteRels = new List <Relation>(); //relations to delete
List <Node> updateValues = new List <Node>(); //value nodes to update
List <KeyValuePair <Node, Anchor> > extendRelations = new List <KeyValuePair <Node, Anchor> >(); //relations to extend
foreach (Relation rel in relations)
{
if (rel.Parent == node || rel.Child == node)
{
deleteRels.Add(rel);
if (rel.Parent == node && rel.Child.Type == NodeType.Value)
{
updateValues.Add(rel.Child);
}
if (rel.Child == node && rel.Parent.Type == NodeType.Event)
{
extendRelations.Add(new KeyValuePair <Node, Anchor>(rel.Parent, rel.ParentAnchor));
}
}
}
if (extendRelations.Count > 0) //if any relations has to be extended
{
Node[] extendedParents = ExtendedParents(node);
foreach (Node vNode in updateValues)
{
ValueOutcome[] oldOutcomes = (vNode.Control as ValueNode).Outcomes; //values before unbundling
ValueOutcome[] newOutcomes = NewOutcomes(vNode, node, extendedParents); //new values after unbundling
foreach (ValueOutcome newOutc in newOutcomes)
{
List <ValueOutcome> relevantOlds = new List <ValueOutcome>();
foreach (ValueOutcome oldOutc in oldOutcomes) // find relevant outcomes out of old ones
{
if (IsRelevant(newOutc, oldOutc) && oldOutc.Factors.Intersect(newOutc.Factors).Any()) //check if value doesnt negate itself and if factors align
{
relevantOlds.Add(oldOutc);
}
}
double newValue = 0;
foreach (ValueOutcome relevant in relevantOlds)
{
foreach (Probability prob in eNode.Probabilities)
{
//probability has any common factors with old relevant outcome and new outcome. It must not negate any of it
if (relevant.Factors.Intersect(prob.Factors).Any() && newOutc.Factors.Intersect(prob.Factors).Any() && IsRelevant(prob, relevant))
{
newValue += relevant.Value * prob.Value;
}
}
}
newOutc.Value = newValue;
}
(vNode.Control as ValueNode).Outcomes = newOutcomes; //assing new values to tha respective value node
(vNode.OutcomeControl as PropertyValue).UpdateOutcomes(); //update UI
foreach (KeyValuePair <Node, Anchor> newParent in extendRelations)
{
new Relation(newParent.Key, newParent.Value, vNode, vNode.TopAnchor, false); //create new extended relation
}
}
}
foreach (Relation rel in deleteRels) //delete all previous relations
{
RemoveRelation(rel);
}
if (extendRelations.Count == 0) //if no realtions have to be extended
{
foreach (Node value in updateValues)
{
ValueNode vNode = value.Control as ValueNode;
ValueOutcome[] oldOutc = vNode.Outcomes;
vNode.UpdateOutcomes(); // have value node produce new outcomes based on parents
foreach (ValueOutcome newOutc in vNode.Outcomes) //go trough every new outcome end find relevant outcomes amongst old ones
{
List <ValueOutcome> relevantOutc = new List <ValueOutcome>();
foreach (ValueOutcome oldc in oldOutc)
{
if (IsRelevant(newOutc, oldc) && newOutc.Factors.Intersect(oldc.Factors).Any())
{
relevantOutc.Add(oldc);
}
}
double newValue = 0;
foreach (ValueOutcome relevantOut in relevantOutc)
{
foreach (Probability prob in eNode.Probabilities)
{
//probability must not negate old relevant outcomes and needs to have common factors
if (IsRelevant(prob, relevantOut) && prob.Factors.Intersect(relevantOut.Factors).Any())
{
newValue += (prob.Value * relevantOut.Value);
}
}
}
newOutc.Value = newValue;
}
(value.OutcomeControl as PropertyValue).UpdateOutcomes(); //update UI
foreach (KeyValuePair <Node, Anchor> newParent in extendRelations) //quite unnecessary
{
new Relation(newParent.Key, newParent.Value, value, value.TopAnchor, false);
}
}
}
RemoveNode(node);
MainWindow.GetCanvas.Children.Remove(node.Control); //remove nodes
MainWindow.GetCanvas.Children.Remove(node.DefinitionControl);
MainWindow.GetCanvas.Children.Remove(node.ProbabilityControl);
CheckCorrectness(); //check if any nodes doesnt have outgoing relations and delete it
RefreshCalculator(); //refresh probability set
}
public static void UnbundleDecision(Node node)
{
List <Relation> deleteRels = new List <Relation>(); //relations to delete
List <Node> updateValues = new List <Node>(); //value nodes to update
List <Node> extendRelations = new List <Node>(); //unnecessary, since no relation will extend
foreach (Relation rel in relations)
{
if (rel.Parent == node || rel.Child == node)
{
deleteRels.Add(rel);
if (rel.Parent == node && rel.Child.Type == NodeType.Value)
{
updateValues.Add(rel.Child);
}
if (rel.Child == node)
{
extendRelations.Add(rel.Parent);
}
}
}
foreach (Relation rel in deleteRels) //remove relations
{
RemoveRelation(rel);
}
foreach (Node value in updateValues)
{
ValueNode vNode = value.Control as ValueNode;
ValueOutcome[] oldOutcomes = vNode.Outcomes; //save old outcomes
vNode.UpdateOutcomes(); //have value node update its outcomes
string bestDecision = ""; //keep track of nodes best decision
foreach (ValueOutcome outc in vNode.Outcomes) //find relevant old outcomes
{
List <ValueOutcome> relevant = new List <ValueOutcome>();
foreach (ValueOutcome olds in oldOutcomes)
{
//when unbundling decision, old outcome has to be a superset to new outcome to be relevant
if (!outc.Factors.Except(olds.Factors).Any())
{
relevant.Add(olds);
}
}
double bestValue = Double.NaN;
foreach (ValueOutcome olds in relevant)
{
//find new best value and decision based on min/max rule
if (vNode.Better == "max")
{
if (Double.IsNaN(bestValue) || olds.Value > bestValue)
{
bestValue = olds.Value;
bestDecision = (olds.Factors.Intersect(node.Definitions).ToArray().First() as string) + " - " + node.Name;
}
}
else if (vNode.Better == "min")
{
if (Double.IsNaN(bestValue) || olds.Value < bestValue)
{
bestValue = olds.Value;
bestDecision = (olds.Factors.Intersect(node.Definitions).ToArray().First() as string) + " - " + node.Name;
}
}
}
outc.Value = bestValue;
}
(value.Control as ValueNode).BestDecisions = (value.Control as ValueNode).BestDecisions.Concat(new string[] { bestDecision }).ToArray(); //save best decision
(value.OutcomeControl as PropertyValue).UpdateOutcomes(); // update UI
}
RemoveNode(node); //remove node
MainWindow.GetCanvas.Children.Remove(node.Control);
MainWindow.GetCanvas.Children.Remove(node.DefinitionControl);
}
public Operation(FieldNode field, ValueNode valueNode)
: base(field, valueNode)
{
}
public void WriteValueAndObjectId(ITextColorWriter output, ValueNode vm, out bool textChanged)
{
WriteValue(output, vm, out textChanged);
WriteObjectId(output, vm);
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueNodeTest"/> class.
/// </summary>
public ValueNodeTest()
{
this._valueNode = new ValueNode <int>(ParameterNodeTest.Identifier, new IntegerDomain());
}
public void WriteValue(ITextColorWriter output, ValueNode vm, out bool textChanged)
{
vm.CachedValue.WriteTo(output);
textChanged = !vm.OldCachedValue.IsDefault && !vm.OldCachedValue.Equals(vm.CachedValue);
}
protected void CreateStoreIncGraph(
OperationValueGraph g, ValueNode x, ValueNode p,
ValueNode pi, int inc)
{
OperationNode storeOp = new StoreOperationNode();
OperationNode addOp = new AddOperationNode();
OperationNode constOp = new ConstOperationNode();
g.AddNode(storeOp);
g.AddNode(addOp);
g.AddNode(constOp);
ValueNode m = new MemoryValueNode(x.Datatype, null);
g.AddNode(m);
ValueNode t = new IntRegisterNode();
ValueNode i = new IntConstantNode(inc);
g.AddNode(t);
g.AddNode(i);
g.AddEdge(x, storeOp);
g.AddEdge(p, storeOp);
g.AddEdge(storeOp, m);
g.AddEdge(p, addOp);
g.AddEdge(i, constOp);
g.AddEdge(constOp, t);
g.AddEdge(t, addOp);
g.AddEdge(addOp, pi);
}
public ValueValueNode(ValueNode parent, string name, TypeNode typeNode)
: base(parent, name, typeNode)
{
}
private void ProcessScope(ScssPackage package, ScopeNode scope, CssRoot root, CssSelector selector, int level,
string nspace = "")
{
if (scope is SelectorNode)
{
var snode = (SelectorNode) scope;
var s = snode.Selector.Resolve(scope);
if (selector != null)
{
s = ExpandSelector(selector.Selector, s);
}
selector = new CssSelector(s, level);
root.Add(selector);
}
foreach (var node in scope.Nodes)
{
var useNode = node;
if (node is PropertyNode)
{
var n = (PropertyNode) node;
var value = n.Expression.Resolve(scope).Value;
selector.Add(new CssProperty(nspace + n.Name.Resolve(scope), value, level + 1));
}
else if (node is MediaNode)
{
var n = (MediaNode) node;
var s = new CssMedia(level + 1)
{
Definition = n.Definition
};
root.Add(s);
int nextLevel = level + 1;
if (selector != null)
{
selector = new CssSelector(selector.Selector, level + 2);
s.Add(selector);
nextLevel++;
}
ProcessScope(package, (ScopeNode) n, s, selector, nextLevel, nspace);
}
else if (node is CommentNode)
{
var n = (CommentNode) node;
CssNode p = root;
if (selector != null)
p = selector;
p.Add(new CssComment(n.Comment, level + 1));
}
else if (node is ImportNode)
{
var n = (ImportNode) node;
if (n.Path.Contains(".css")
|| n.Path.Contains("http://")
|| n.Path.Contains("url(")
|| n.Path.Contains(" "))
{
root.Add(new CssImport(n.Path, level + 1));
}
else
{
var path = n.Path.Trim('\"');
ProcessImport(path, package, scope, root, selector, level, nspace);
}
}
else if (node is VariableNode)
{
var n = (VariableNode) node;
scope.SetVariable(n);
}
else if (node is MixinNode)
{
var n = (MixinNode) node;
scope.SetMixin(n);
}
else if (node is ContentNode)
{
var sn = scope.GetContent();
ProcessScope(package, sn, root, selector, level - 1, nspace);
}
else if (node is IfNode)
{
var n = (IfNode) node;
var sn = n.GetActiveScope(scope);
if (sn != null)
ProcessScope(package, sn, root, selector, level, nspace);
}
else if (node is EachNode)
{
var n = (EachNode) node;
var var = n.Variables;
foreach (var value in n.List)
{
if (var.Count == 1)
{
var[0].Expression = new Expression(value);
n.SetVariable(var[0]);
}
else
{
if (!(value is ValueList))
throw new Exception("This must be a list");
var subList = (ValueList) value;
// There is a bug in the reader causing unecessary levels of value lists
// TODO UNDONE
if (subList.Count == 1)
subList = (ValueList) subList[0];
for (int i = 0; i < var.Count; i++)
{
var[i].Expression = new Expression(subList[i]);
n.SetVariable(var[i]);
}
}
ProcessScope(package, n, root, selector, level, nspace);
}
}
else if (node is ForNode)
{
var n = (ForNode) node;
var var = n.Variable;
int from = int.Parse(n.From.Resolve(scope).Value);
int to = 0;
string toStr = n.Through.Resolve(scope).Value;
if (!int.TryParse(toStr, out to))
throw new Exception("Failed to parse to value");
for (int i = from; i <= to; i++)
{
var value = new ValueNode(i.ToString());
var.Expression = new Expression(value);
n.SetVariable(var);
ProcessScope(package, n, root, selector, level, nspace);
}
}
else if (node is ExtendNode)
{
var n = (ExtendNode) node;
package.AddExtension(new ScssExtension()
{
Selector = selector.Selector,
Super = ((ExtendNode) node).Selector
});
}
else if (node is FunctionNode)
{
var n = (FunctionNode) node;
scope.SetFunction(n);
}
else if (node is NamespaceNode)
{
var subLevel = level;
var n = (NamespaceNode) node;
string header = n.Header.Name.Resolve(scope);
if (!n.Header.Expression.Empty)
{
var value = n.Header.Expression.Resolve(scope).Value;
selector.Add(new CssProperty(header, value, level + 1));
subLevel++;
}
ProcessScope(package, (ScopeNode) node, root, selector, subLevel, header + "-");
}
else if (node is IncludeNode)
{
var n = (IncludeNode) node;
var mn = scope.GetMixin(n.MixinName);
mn.Initialize(n);
ProcessScope(package, mn, root, selector, level);
}
else if (useNode is SelectorNode)
{
ProcessScope(package, (ScopeNode) node, root, selector, level + 1);
}
}
}
public static IEnumerable <Instruction> PushConvertedValue(this ValueNode node, ILContext context,
TypeReference targetTypeRef, TypeReference typeConverter, IEnumerable <Instruction> pushServiceProvider,
bool boxValueTypes, bool unboxValueTypes)
{
var module = context.Body.Method.Module;
var str = (string)node.Value;
//If the TypeConverter has a ProvideCompiledAttribute that can be resolved, shortcut this
var compiledConverterName = typeConverter?.GetCustomAttribute(module, ("Xamarin.Forms.Core", "Xamarin.Forms.Xaml", "ProvideCompiledAttribute"))?.ConstructorArguments?.First().Value as string;
Type compiledConverterType;
if (compiledConverterName != null && (compiledConverterType = Type.GetType(compiledConverterName)) != null)
{
var compiledConverter = Activator.CreateInstance(compiledConverterType);
var converter = typeof(ICompiledTypeConverter).GetMethods().FirstOrDefault(md => md.Name == "ConvertFromString");
IEnumerable <Instruction> instructions;
try {
instructions = (IEnumerable <Instruction>)converter.Invoke(compiledConverter, new object[] {
node.Value as string, context, node as BaseNode
});
} catch (System.Reflection.TargetInvocationException tie) when(tie.InnerException is XamlParseException)
{
throw tie.InnerException;
}
foreach (var i in instructions)
{
yield return(i);
}
if (targetTypeRef.IsValueType && boxValueTypes)
{
yield return(Instruction.Create(OpCodes.Box, module.ImportReference(targetTypeRef)));
}
yield break;
}
//If there's a [TypeConverter], use it
if (typeConverter != null)
{
var isExtendedConverter = typeConverter.ImplementsInterface(module.ImportReference(("Xamarin.Forms.Core", "Xamarin.Forms", "IExtendedTypeConverter")));
var typeConverterCtorRef = module.ImportCtorReference(typeConverter, paramCount: 0);
var convertFromInvariantStringDefinition = isExtendedConverter
? module.ImportReference(("Xamarin.Forms.Core", "Xamarin.Forms", "IExtendedTypeConverter"))
.ResolveCached()
.Methods.FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 2)
: typeConverter.ResolveCached()
.AllMethods()
.FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 1);
var convertFromInvariantStringReference = module.ImportReference(convertFromInvariantStringDefinition);
yield return(Instruction.Create(OpCodes.Newobj, typeConverterCtorRef));
yield return(Instruction.Create(OpCodes.Ldstr, node.Value as string));
if (isExtendedConverter)
{
foreach (var instruction in pushServiceProvider)
{
yield return(instruction);
}
}
yield return(Instruction.Create(OpCodes.Callvirt, convertFromInvariantStringReference));
if (targetTypeRef.IsValueType && unboxValueTypes)
{
yield return(Instruction.Create(OpCodes.Unbox_Any, module.ImportReference(targetTypeRef)));
}
//ConvertFrom returns an object, no need to Box
yield break;
}
var originalTypeRef = targetTypeRef;
var isNullable = false;
MethodReference nullableCtor = null;
if (targetTypeRef.ResolveCached().FullName == "System.Nullable`1")
{
var nullableTypeRef = targetTypeRef;
targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0];
isNullable = true;
nullableCtor = originalTypeRef.GetMethods(md => md.IsConstructor && md.Parameters.Count == 1, module).Single().Item1;
nullableCtor = nullableCtor.ResolveGenericParameters(nullableTypeRef, module);
}
var implicitOperator = module.TypeSystem.String.GetImplicitOperatorTo(targetTypeRef, module);
//Obvious Built-in conversions
if (targetTypeRef.ResolveCached().BaseType != null && targetTypeRef.ResolveCached().BaseType.FullName == "System.Enum")
{
yield return(PushParsedEnum(targetTypeRef, str, node));
}
else if (targetTypeRef.FullName == "System.Char")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, Char.Parse(str)));
}
else if (targetTypeRef.FullName == "System.SByte")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, SByte.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Int16")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, Int16.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Int32")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, Int32.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Int64")
{
yield return(Instruction.Create(OpCodes.Ldc_I8, Int64.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Byte")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, Byte.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.UInt16")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, unchecked ((int)UInt16.Parse(str, CultureInfo.InvariantCulture))));
}
else if (targetTypeRef.FullName == "System.UInt32")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, unchecked ((int)UInt32.Parse(str, CultureInfo.InvariantCulture))));
}
else if (targetTypeRef.FullName == "System.UInt64")
{
yield return(Instruction.Create(OpCodes.Ldc_I8, unchecked ((long)UInt64.Parse(str, CultureInfo.InvariantCulture))));
}
else if (targetTypeRef.FullName == "System.Single")
{
yield return(Instruction.Create(OpCodes.Ldc_R4, Single.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Double")
{
yield return(Instruction.Create(OpCodes.Ldc_R8, Double.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Boolean")
{
if (Boolean.Parse(str))
{
yield return(Instruction.Create(OpCodes.Ldc_I4_1));
}
else
{
yield return(Instruction.Create(OpCodes.Ldc_I4_0));
}
}
else if (targetTypeRef.FullName == "System.TimeSpan")
{
var ts = TimeSpan.Parse(str, CultureInfo.InvariantCulture);
var ticks = ts.Ticks;
yield return(Instruction.Create(OpCodes.Ldc_I8, ticks));
yield return(Instruction.Create(OpCodes.Newobj, module.ImportCtorReference(("mscorlib", "System", "TimeSpan"), parameterTypes: new[] { ("mscorlib", "System", "Int64") })));
internal OpLess(FieldNode field, ValueNode valueNode)
: base(field, valueNode)
{
}
private ResolveNodeBase InnerBuildResolveTree(Type interfaceType, ICollection <Type> discoveredTypes, List <IParameterValue> userDefinedParameters = null)
{
// Factory ?
Func <object> factory;
if (_factories.TryGetValue(interfaceType, out factory))
{
return new FactoryNode
{
InterfaceType = interfaceType,
Factory = factory
}
}
;
// Instance ?
object instance;
if (_instances.TryGetValue(interfaceType, out instance))
{
return new InstanceNode
{
InterfaceType = interfaceType,
Instance = instance
}
}
;
// Implementation ?
Type implementationType;
if (!_implementations.TryGetValue(interfaceType, out implementationType))
{
return(ErrorNode.TypeNotRegistered);
}
ConstructorInfo[] constructorInfos = implementationType.GetConstructors();
// Valid constructor ?
if (constructorInfos.Length == 0 ||
(constructorInfos.Length == 1 && !constructorInfos[0].IsPublic))
{
return(ErrorNode.NoPublicConstructorOrNoConstructor);
}
// Get parameters for each ctor
var constructorAndParameters = constructorInfos.Select(x => new
{
Constructor = x,
Parameters = x.GetParameters()
}).ToList();
// Get first parameterless if any
var parameterless = constructorAndParameters.FirstOrDefault(x => x.Parameters.Length == 0);
if (parameterless != null)
{
return new BuildableNode
{
InterfaceType = interfaceType,
ConstructorInfo = parameterless.Constructor
}
}
;
// Check if every ctor's parameter is registered in container or resolvable, returns first resolvable
foreach (var c in constructorAndParameters)
{
List <ResolveNodeBase> parametersResolvable = new List <ResolveNodeBase>(c.Parameters.Length);
// Try to resolved every parameters
bool ok = true;
foreach (ParameterInfo parameterInfo in c.Parameters)
{
IParameterValue parameterValue = userDefinedParameters?.FirstOrDefault(x => x.Name == parameterInfo.Name);
if (parameterValue != null)
{
ValueNode parameter = new ValueNode
{
InterfaceType = null,
ParameterValue = parameterValue
};
parametersResolvable.Add(parameter);
}
else
{
if (discoveredTypes.Any(x => x == parameterInfo.ParameterType)) // check cyclic dependency
{
ok = false;
break;
}
discoveredTypes.Add(parameterInfo.ParameterType); // add parameter type to discovered type
ResolveNodeBase parameter = InnerBuildResolveTree(parameterInfo.ParameterType, discoveredTypes, userDefinedParameters);
discoveredTypes.Remove(parameterInfo.ParameterType); // remove parameter type from discovered type
if (parameter is ErrorNode) // once an invalid ctor parameter has been found, try next ctor
{
ok = false;
break;
}
parametersResolvable.Add(parameter);
}
}
if (ok)
{
return new BuildableNode
{
InterfaceType = interfaceType,
ConstructorInfo = c.Constructor,
Parameters = parametersResolvable
}
}
;
}
return(ErrorNode.NoResolvableConstructor);
}
#endregion
}
}
public void Visit(ValueNode node, INode parentNode)
{
Context.Values[node] = node.Value;
}
internal OpBeginsWith(FieldNode field, ValueNode valueNode)
: base(field, valueNode)
{
}
public static bool CanConvertValue(this ValueNode node, ILContext context, TypeReference targetTypeRef, TypeReference typeConverter)
{
var str = (string)node.Value;
var module = context.Body.Method.Module;
//If there's a [TypeConverter], use it
if (typeConverter != null && str != null)
{
var typeConvAttribute = typeConverter.GetCustomAttribute(module, ("Xamarin.Forms.Core", "Xamarin.Forms.Xaml", "TypeConversionAttribute"));
if (typeConvAttribute == null) //trust the unattributed TypeConverter
{
return(true);
}
var toType = typeConvAttribute.ConstructorArguments.First().Value as TypeReference;
return(toType.InheritsFromOrImplements(targetTypeRef));
}
//check if it's assignable from a string
if (targetTypeRef.ResolveCached().FullName == "System.Nullable`1")
{
targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0];
}
if (targetTypeRef.ResolveCached().BaseType != null && targetTypeRef.ResolveCached().BaseType.FullName == "System.Enum")
{
return(true);
}
if (targetTypeRef.FullName == "System.Char")
{
return(true);
}
if (targetTypeRef.FullName == "System.SByte")
{
return(true);
}
if (targetTypeRef.FullName == "System.Int16")
{
return(true);
}
if (targetTypeRef.FullName == "System.Int32")
{
return(true);
}
if (targetTypeRef.FullName == "System.Int64")
{
return(true);
}
if (targetTypeRef.FullName == "System.Byte")
{
return(true);
}
if (targetTypeRef.FullName == "System.UInt16")
{
return(true);
}
if (targetTypeRef.FullName == "System.UInt32")
{
return(true);
}
if (targetTypeRef.FullName == "System.UInt64")
{
return(true);
}
if (targetTypeRef.FullName == "System.Single")
{
return(true);
}
if (targetTypeRef.FullName == "System.Double")
{
return(true);
}
if (targetTypeRef.FullName == "System.Boolean")
{
return(true);
}
if (targetTypeRef.FullName == "System.TimeSpan")
{
return(true);
}
if (targetTypeRef.FullName == "System.DateTime")
{
return(true);
}
if (targetTypeRef.FullName == "System.String")
{
return(true);
}
if (targetTypeRef.FullName == "System.Object")
{
return(true);
}
if (targetTypeRef.FullName == "System.Decimal")
{
return(true);
}
var implicitOperator = module.TypeSystem.String.GetImplicitOperatorTo(targetTypeRef, module);
if (implicitOperator != null)
{
return(true);
}
return(false);
}
/// <summary>Evaluates whether the signal is zero (0).</summary>
public static bool IsAdditiveIdentity(ValueNode signal)
{
if(signal == null)
throw new ArgumentNullException("signal");
IAlgebraicAdditiveIdentityElement monoid = signal.Value as IAlgebraicAdditiveIdentityElement;
return monoid != null && monoid.IsAdditiveIdentity;
}
public void Visit(ElementNode node, INode parentNode)
{
var typeref = node.XmlType.GetTypeReference(Module, node);
TypeDefinition typedef = typeref.Resolve();
if (IsXaml2009LanguagePrimitive(node))
{
var vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(PushValueFromLanguagePrimitive(typedef, node));
Context.IL.Emit(OpCodes.Stloc, vardef);
return;
}
if (typeref.FullName == "Xamarin.Forms.Xaml.StaticExtension")
{
var markupProvider = new StaticExtension();
var il = markupProvider.ProvideValue(node, Module, out typeref);
var vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
node.Properties.Clear();
node.CollectionItems.Clear();
return;
}
MethodDefinition factoryCtorInfo = null;
MethodDefinition factoryMethodInfo = null;
MethodDefinition parameterizedCtorInfo = null;
MethodDefinition ctorInfo = null;
if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.MatchXArguments(node, Module, Context));
if (factoryCtorInfo == null)
{
throw new XamlParseException(
string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node);
}
ctorInfo = factoryCtorInfo;
if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params
{
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
}
}
else if (node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
var factoryMethod = (string)(node.Properties [XmlName.xFactoryMethod] as ValueNode).Value;
factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, Module, Context));
if (factoryMethodInfo == null)
{
throw new XamlParseException(
String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node);
}
Context.IL.Append(PushCtorXArguments(factoryMethodInfo, node));
}
if (ctorInfo == null && factoryMethodInfo == null)
{
parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.Parameters.All(
pd =>
pd.CustomAttributes.Any(
ca =>
ca.AttributeType.FullName ==
"Xamarin.Forms.ParameterAttribute")));
}
if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node))
{
ctorInfo = parameterizedCtorInfo;
// IL_0000: ldstr "foo"
Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node));
}
ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic);
var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module);
var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module);
var implicitOperatorref = typedef.Methods.FirstOrDefault(md =>
md.IsPublic &&
md.IsStatic &&
md.IsSpecialName &&
md.Name == "op_Implicit" && md.Parameters [0].ParameterType.FullName == "System.String");
if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType)
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables [node] = vardef;
Context.Body.Variables.Add(vardef);
ValueNode vnode = null;
if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
vardef.VariableType.IsValueType)
{
//<Color>Purple</Color>
Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider [] { typedef },
node.PushServiceProvider(Context), false, true));
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
implicitOperatorref != null)
{
//<FileImageSource>path.png</FileImageSource>
var implicitOperator = Module.Import(implicitOperatorref);
Context.IL.Emit(OpCodes.Ldstr, ((ValueNode)(node.CollectionItems.First())).Value as string);
Context.IL.Emit(OpCodes.Call, implicitOperator);
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (factorymethodinforef != null)
{
var factory = Module.Import(factorymethodinforef);
Context.IL.Emit(OpCodes.Call, factory);
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (!typedef.IsValueType)
{
var ctor = Module.Import(ctorinforef);
// IL_0001: newobj instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::'.ctor'()
// IL_0006: stloc.0
Context.IL.Emit(OpCodes.Newobj, ctor);
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) &&
!node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, Module, Context))
{
// IL_0008: ldloca.s 1
// IL_000a: ldc.i4.1
// IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool)
var ctor = Module.Import(ctorinforef);
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
Context.IL.Emit(OpCodes.Call, ctor);
}
else
{
// IL_0000: ldloca.s 0
// IL_0002: initobj Test/Foo
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Emit(OpCodes.Initobj, Module.Import(typedef));
}
//if/when we land the compiled converters, those 2 blocks could be greatly simplified
if (typeref.FullName == "Xamarin.Forms.Xaml.TypeExtension")
{
var visitor = new SetPropertiesVisitor(Context);
foreach (var cnode in node.Properties.Values.ToList())
{
cnode.Accept(visitor, node);
}
foreach (var cnode in node.CollectionItems)
{
cnode.Accept(visitor, node);
}
//As we're stripping the TypeExtension bare, keep the type if we need it later (hint: we do need it)
INode ntype;
if (!node.Properties.TryGetValue(new XmlName("", "TypeName"), out ntype))
{
ntype = node.CollectionItems [0];
}
var type = ((ValueNode)ntype).Value as string;
var namespaceuri = type.Contains(":") ? node.NamespaceResolver.LookupNamespace(type.Split(':') [0].Trim()) : "";
type = type.Contains(":") ? type.Split(':') [1].Trim() : type;
Context.TypeExtensions [node] = new XmlType(namespaceuri, type, null).GetTypeReference(Module, node);
if (!node.SkipProperties.Contains(new XmlName("", "TypeName")))
{
node.SkipProperties.Add(new XmlName("", "TypeName"));
}
var vardefref = new VariableDefinitionReference(vardef);
Context.IL.Append(SetPropertiesVisitor.ProvideValue(vardefref, Context, Module, node));
if (vardef != vardefref.VariableDefinition)
{
Context.Variables [node] = vardefref.VariableDefinition;
Context.Body.Variables.Add(vardefref.VariableDefinition);
}
}
}
}
public static bool IsUndefined(ValueNode signal)
{
if(signal == null)
throw new ArgumentNullException("signal");
return signal.Value is MathNet.Symbolics.Packages.Standard.Structures.UndefinedSymbol;
}
public override void Remove(ValueNode <TItem> item)
{
Remove(this.SelectKey(item.Value));
}
public ValueNodeEventArgs(ValueNode node)
{
_node = node;
}
internal OpGreater(FieldNode field, ValueNode valueNode)
: base(field, valueNode)
{
}
protected override bool Equals(ValueNode <byte> node)
{
return(Value == node.Value);
}
/// <summary>Evaluates whether the signal is one (1).</summary>
public static bool IsMultiplicativeIdentity(ValueNode signal)
{
if(signal == null)
throw new ArgumentNullException("signal");
IAlgebraicMultiplicativeIdentityElement ring = signal.Value as IAlgebraicMultiplicativeIdentityElement;
return ring != null && ring.IsMultiplicativeIdentity;
}
public static IEnumerable <Instruction> PushConvertedValue(this ValueNode node, ILContext context,
TypeReference targetTypeRef, TypeReference typeConverter, IEnumerable <Instruction> pushServiceProvider,
bool boxValueTypes, bool unboxValueTypes)
{
var module = context.Body.Method.Module;
var str = (string)node.Value;
//If the TypeConverter has a ProvideCompiledAttribute that can be resolved, shortcut this
var compiledConverterName = typeConverter?.GetCustomAttribute(module.ImportReference(typeof(ProvideCompiledAttribute)))?.ConstructorArguments?.First().Value as string;
Type compiledConverterType;
if (compiledConverterName != null && (compiledConverterType = Type.GetType(compiledConverterName)) != null)
{
var compiledConverter = Activator.CreateInstance(compiledConverterType);
var converter = typeof(ICompiledTypeConverter).GetMethods().FirstOrDefault(md => md.Name == "ConvertFromString");
var instructions = (IEnumerable <Instruction>)converter.Invoke(compiledConverter, new object[] {
node.Value as string, context, node as BaseNode
});
foreach (var i in instructions)
{
yield return(i);
}
if (targetTypeRef.IsValueType && boxValueTypes)
{
yield return(Instruction.Create(OpCodes.Box, module.ImportReference(targetTypeRef)));
}
yield break;
}
//If there's a [TypeConverter], use it
if (typeConverter != null)
{
var isExtendedConverter = typeConverter.ImplementsInterface(module.ImportReference(typeof(IExtendedTypeConverter)));
var typeConverterCtor = typeConverter.Resolve().Methods.Single(md => md.IsConstructor && md.Parameters.Count == 0 && !md.IsStatic);
var typeConverterCtorRef = module.ImportReference(typeConverterCtor);
var convertFromInvariantStringDefinition = isExtendedConverter
? module.ImportReference(typeof(IExtendedTypeConverter))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 2)
: typeConverter.Resolve()
.AllMethods()
.FirstOrDefault(md => md.Name == "ConvertFromInvariantString" && md.Parameters.Count == 1);
var convertFromInvariantStringReference = module.ImportReference(convertFromInvariantStringDefinition);
yield return(Instruction.Create(OpCodes.Newobj, typeConverterCtorRef));
yield return(Instruction.Create(OpCodes.Ldstr, node.Value as string));
if (isExtendedConverter)
{
foreach (var instruction in pushServiceProvider)
{
yield return(instruction);
}
}
yield return(Instruction.Create(OpCodes.Callvirt, convertFromInvariantStringReference));
if (targetTypeRef.IsValueType && unboxValueTypes)
{
yield return(Instruction.Create(OpCodes.Unbox_Any, module.ImportReference(targetTypeRef)));
}
//ConvertFrom returns an object, no need to Box
yield break;
}
var originalTypeRef = targetTypeRef;
var isNullable = false;
MethodReference nullableCtor = null;
if (targetTypeRef.Resolve().FullName == "System.Nullable`1")
{
var nullableTypeRef = targetTypeRef;
targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0];
isNullable = true;
nullableCtor = originalTypeRef.GetMethods(md => md.IsConstructor && md.Parameters.Count == 1, module).Single().Item1;
nullableCtor = nullableCtor.ResolveGenericParameters(nullableTypeRef, module);
}
var implicitOperator = module.TypeSystem.String.GetImplicitOperatorTo(targetTypeRef, module);
//Obvious Built-in conversions
if (targetTypeRef.Resolve().BaseType != null && targetTypeRef.Resolve().BaseType.FullName == "System.Enum")
{
yield return(PushParsedEnum(targetTypeRef, str, node));
}
else if (targetTypeRef.FullName == "System.Char")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, Char.Parse(str)));
}
else if (targetTypeRef.FullName == "System.SByte")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, SByte.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Int16")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, Int16.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Int32")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, Int32.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Int64")
{
yield return(Instruction.Create(OpCodes.Ldc_I8, Int64.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Byte")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, Byte.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.UInt16")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, unchecked ((int)UInt16.Parse(str, CultureInfo.InvariantCulture))));
}
else if (targetTypeRef.FullName == "System.UInt32")
{
yield return(Instruction.Create(OpCodes.Ldc_I4, UInt32.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.UInt64")
{
yield return(Instruction.Create(OpCodes.Ldc_I8, unchecked ((long)UInt64.Parse(str, CultureInfo.InvariantCulture))));
}
else if (targetTypeRef.FullName == "System.Single")
{
yield return(Instruction.Create(OpCodes.Ldc_R4, Single.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Double")
{
yield return(Instruction.Create(OpCodes.Ldc_R8, Double.Parse(str, CultureInfo.InvariantCulture)));
}
else if (targetTypeRef.FullName == "System.Boolean")
{
if (Boolean.Parse(str))
{
yield return(Instruction.Create(OpCodes.Ldc_I4_1));
}
else
{
yield return(Instruction.Create(OpCodes.Ldc_I4_0));
}
}
else if (targetTypeRef.FullName == "System.TimeSpan")
{
var ts = TimeSpan.Parse(str, CultureInfo.InvariantCulture);
var ticks = ts.Ticks;
var timeSpanCtor =
module.ImportReference(typeof(TimeSpan))
.Resolve()
.Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 1);
var timeSpanCtorRef = module.ImportReference(timeSpanCtor);
yield return(Instruction.Create(OpCodes.Ldc_I8, ticks));
yield return(Instruction.Create(OpCodes.Newobj, timeSpanCtorRef));
}
else if (targetTypeRef.FullName == "System.DateTime")
{
var dt = DateTime.Parse(str, CultureInfo.InvariantCulture);
var ticks = dt.Ticks;
var dateTimeCtor =
module.ImportReference(typeof(DateTime))
.Resolve()
.Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 1);
var dateTimeCtorRef = module.ImportReference(dateTimeCtor);
yield return(Instruction.Create(OpCodes.Ldc_I8, ticks));
yield return(Instruction.Create(OpCodes.Newobj, dateTimeCtorRef));
}
else if (targetTypeRef.FullName == "System.String" && str.StartsWith("{}", StringComparison.Ordinal))
{
yield return(Instruction.Create(OpCodes.Ldstr, str.Substring(2)));
}
else if (targetTypeRef.FullName == "System.String")
{
yield return(Instruction.Create(OpCodes.Ldstr, str));
}
else if (targetTypeRef.FullName == "System.Object")
{
yield return(Instruction.Create(OpCodes.Ldstr, str));
}
else if (targetTypeRef.FullName == "System.Decimal")
{
decimal outdecimal;
if (decimal.TryParse(str, NumberStyles.Number, CultureInfo.InvariantCulture, out outdecimal))
{
var vardef = new VariableDefinition(context.Body.Method.Module.ImportReference(typeof(decimal)));
context.Body.Variables.Add(vardef);
//Use an extra temp var so we can push the value to the stack, just like other cases
// IL_0003: ldstr "adecimal"
// IL_0008: ldc.i4.s 0x6f
// IL_000a: call class [mscorlib]System.Globalization.CultureInfo class [mscorlib]System.Globalization.CultureInfo::get_InvariantCulture()
// IL_000f: ldloca.s 0
// IL_0011: call bool valuetype [mscorlib]System.Decimal::TryParse(string, valuetype [mscorlib]System.Globalization.NumberStyles, class [mscorlib]System.IFormatProvider, [out] valuetype [mscorlib]System.Decimal&)
// IL_0016: pop
yield return(Instruction.Create(OpCodes.Ldstr, str));
yield return(Instruction.Create(OpCodes.Ldc_I4, 0x6f)); //NumberStyles.Number
var getInvariantInfo =
context.Body.Method.Module.ImportReference(typeof(CultureInfo))
.Resolve()
.Properties.FirstOrDefault(pd => pd.Name == "InvariantCulture")
.GetMethod;
var getInvariant = context.Body.Method.Module.ImportReference(getInvariantInfo);
yield return(Instruction.Create(OpCodes.Call, getInvariant));
yield return(Instruction.Create(OpCodes.Ldloca, vardef));
var tryParseInfo =
context.Body.Method.Module.ImportReference(typeof(decimal))
.Resolve()
.Methods.FirstOrDefault(md => md.Name == "TryParse" && md.Parameters.Count == 4);
var tryParse = context.Body.Method.Module.ImportReference(tryParseInfo);
yield return(Instruction.Create(OpCodes.Call, tryParse));
yield return(Instruction.Create(OpCodes.Pop));
yield return(Instruction.Create(OpCodes.Ldloc, vardef));
}
else
{
yield return(Instruction.Create(OpCodes.Ldc_I4_0));
var decimalctorinfo =
context.Body.Method.Module.ImportReference(typeof(decimal))
.Resolve()
.Methods.FirstOrDefault(
md => md.IsConstructor && md.Parameters.Count == 1 && md.Parameters[0].ParameterType.FullName == "System.Int32");
var decimalctor = context.Body.Method.Module.ImportReference(decimalctorinfo);
yield return(Instruction.Create(OpCodes.Newobj, decimalctor));
}
}
else if (implicitOperator != null)
{
yield return(Instruction.Create(OpCodes.Ldstr, node.Value as string));
yield return(Instruction.Create(OpCodes.Call, module.ImportReference(implicitOperator)));
}
else
{
yield return(Instruction.Create(OpCodes.Ldnull));
}
if (isNullable)
{
yield return(Instruction.Create(OpCodes.Newobj, module.ImportReference(nullableCtor)));
}
if (originalTypeRef.IsValueType && boxValueTypes)
{
yield return(Instruction.Create(OpCodes.Box, module.ImportReference(originalTypeRef)));
}
}
public PropertyValue(ValueNode owner)
{
InitializeComponent();
this.owner = owner;
outcomes = owner.Outcomes;
StackPanel first = new StackPanel {
Orientation = Orientation.Horizontal
};
foreach (ValueOutcome outc in outcomes)
{
foreach (Node fac in outc.FacNodes)
{
first.Children.Add(new Label {
Content = fac.Name, Width = 100, FontWeight = FontWeights.Bold
});
}
break;
}
first.Children.Add(new Label {
Content = owner.Name, Width = 100, FontWeight = FontWeights.Bold
});
this.Container.Children.Add(first);
foreach (ValueOutcome outc in outcomes)
{
StackPanel sp = new StackPanel {
Orientation = Orientation.Horizontal
};
string[] items = outc.Factors.ToArray();
foreach (string item in items)
{
sp.Children.Add(new Label {
Content = item.Substring(owner.Owner.ID.Length + 1), Width = 100
});
}
sp.Children.Add(new TextBox {
Text = outc.Value.ToString(), Width = 100
});
this.Container.Children.Add(sp);
}
if (owner.BestDecisions.Length > 0)
{
Container.Children.Add(new Label {
Content = "BestDecisions", FontStyle = FontStyles.Italic
});
foreach (string bestDecision in owner.BestDecisions)
{
Container.Children.Add(new Label {
Content = bestDecision.Substring(owner.Owner.ID.Length + 1)
});
}
}
Button save = new Button {
Content = "Save Values"
};
save.Click += Save_Click;
this.Container.Children.Add(save);
LayoutUpdated += PropertyValue_LayoutUpdated;
this.SetBinding(PropertyValue.AnchorX1Property, new Binding()
{
Source = owner.Owner,
Path = new PropertyPath(Node.AnchorRightXProperty)
});
this.SetBinding(PropertyValue.AnchorY1Property, new Binding()
{
Source = owner.Owner,
Path = new PropertyPath(Node.AnchorRightYProperty)
});
this.SetBinding(Canvas.LeftProperty, new Binding()
{
Source = this,
Path = new PropertyPath(PropertyValue.AnchorX1Property)
});
this.SetBinding(Canvas.TopProperty, new Binding()
{
Source = this,
Path = new PropertyPath(PropertyValue.AnchorY1Property)
});
MainWindow.GetCanvas.Children.Add(this);
}
private void Date(ExpressionType expType, ValueNode value)
{
var date = (DateValueNode)value;
if (date.Year != null)
{
if (date.Year < 1900 || date.Year > 2200)
throw new SchyntaxParseException("Year " + date.Year + " is not a valid year. Must be between 1900 and 2200.", Input, date.Index);
}
if (date.Month < 1 || date.Month > 12)
{
throw new SchyntaxParseException("Month " + date.Month + " is not a valid month. Must be between 1 and 12.", Input, date.Index);
}
var daysInMonth = DateTime.DaysInMonth(date.Year ?? 2000, date.Month); // default to a leap year, if no year is specified
if (date.Day < 1 || date.Day > daysInMonth)
{
throw new SchyntaxParseException(date.Day + " is not a valid day for the month specified. Must be between 1 and " + daysInMonth, Input, date.Index);
}
}
protected void CreateLoadIncGraph(
OperationValueGraph g, ValueNode x, ValueNode p,
ValueNode pi, int inc)
{
OperationNode loadOp = new LoadOperationNode();
OperationNode addOp = new AddOperationNode();
OperationNode constOp = new ConstOperationNode();
g.AddNode(loadOp);
g.AddNode(addOp);
g.AddNode(constOp);
ValueNode t = new IntRegisterNode();
ValueNode i = new IntConstantNode(inc);
g.AddNode(t);
g.AddNode(i);
g.AddEdge(p, loadOp);
g.AddEdge(loadOp, x);
g.AddEdge(p, addOp);
g.AddEdge(i, constOp);
g.AddEdge(constOp, t);
g.AddEdge(t, addOp);
g.AddEdge(addOp, pi);
}
IEnumerable <Instruction> PushCtorXArguments(MethodDefinition factoryCtorInfo, ElementNode enode)
{
if (!enode.Properties.ContainsKey(XmlName.xArguments))
{
yield break;
}
var arguments = new List <INode>();
var node = enode.Properties[XmlName.xArguments] as ElementNode;
if (node != null)
{
node.Accept(new SetPropertiesVisitor(Context, true), null);
arguments.Add(node);
}
var list = enode.Properties[XmlName.xArguments] as ListNode;
if (list != null)
{
foreach (var n in list.CollectionItems)
{
arguments.Add(n);
}
}
for (var i = 0; i < arguments.Count; i++)
{
var parameter = factoryCtorInfo.Parameters[i];
var arg = arguments[i];
VariableDefinition vardef;
ValueNode vnode = null;
if (arg is IElementNode && (vardef = Context.Variables[arg as IElementNode]) != null)
{
yield return(Instruction.Create(OpCodes.Ldloc, vardef));
}
else if ((vnode = arg as ValueNode) != null)
{
foreach (var instruction in vnode.PushConvertedValue(Context,
parameter.ParameterType,
new ICustomAttributeProvider[] { parameter, parameter.ParameterType.ResolveCached() },
enode.PushServiceProvider(Context), false, true))
{
yield return(instruction);
}
}
}
for (var i = arguments.Count; i < factoryCtorInfo.Parameters.Count; i++)
{
var parameter = factoryCtorInfo.Parameters[i];
var arg = new ValueNode(parameter.Constant?.ToString(), node?.NamespaceResolver);
foreach (var instruction in arg.PushConvertedValue(Context,
parameter.ParameterType,
new ICustomAttributeProvider[] { parameter, parameter.ParameterType.ResolveCached() },
enode.PushServiceProvider(Context), false, true))
{
yield return(instruction);
}
}
}
protected void CreateSingleFilterLoop(
ProgramGraph g, ValueNode x, ValueNode x0, ValueNode x1,
ValueNode c0, ValueNode c1, ValueNode c2, ValueNode c3, ValueNode c4,
ValueNode z0, ValueNode z1, ValueNode y)
{
OperationNode[] o = new OperationNode[13];
o[0] = new AddOperationNode();
o[1] = new MulOperationNode();
o[2] = new AddOperationNode();
o[3] = new AddOperationNode();
o[4] = new MulOperationNode();
o[5] = new AddOperationNode();
o[6] = new AddOperationNode();
o[7] = new AddOperationNode();
o[8] = new MulOperationNode();
o[9] = new MulOperationNode();
o[10] = new MulOperationNode();
o[11] = new AddOperationNode();
o[12] = new AddOperationNode();
foreach (OperationNode opNode in o)
g.AddNode(opNode);
ValueNode[] v = new ValueNode[10];
for (int i = 0; i < v.Length; i++)
v[i] = new FloatRegisterNode();
foreach (ValueNode vNode in v)
g.AddNode(vNode);
g.AddEdge(x, o[0]);
g.AddEdge(x0, o[0]);
g.AddEdge(o[0], v[0]);
g.AddEdge(c0, o[1]);
g.AddEdge(v[0], o[1]);
g.AddEdge(o[1], v[1]);
g.AddEdge(x, o[2]);
g.AddEdge(v[1], o[2]);
g.AddEdge(o[2], v[2]);
g.AddEdge(v[2], o[3]);
g.AddEdge(x1, o[3]);
g.AddEdge(o[3], v[3]);
g.AddEdge(c1, o[4]);
g.AddEdge(v[3], o[4]);
g.AddEdge(o[4], v[4]);
g.AddEdge(v[2], o[5]);
g.AddEdge(v[4], o[5]);
g.AddEdge(o[5], z1);
g.AddEdge(v[1], o[6]);
g.AddEdge(x0, o[6]);
g.AddEdge(o[6], v[5]);
g.AddEdge(v[4], o[7]);
g.AddEdge(x1, o[7]);
g.AddEdge(o[7], z0);
g.AddEdge(v[5], o[8]);
g.AddEdge(c2, o[8]);
g.AddEdge(o[8], v[6]);
g.AddEdge(z0, o[9]);
g.AddEdge(c3, o[9]);
g.AddEdge(o[9], v[7]);
g.AddEdge(z1, o[10]);
g.AddEdge(c4, o[10]);
g.AddEdge(o[10], v[9]);
g.AddEdge(v[6], o[11]);
g.AddEdge(v[7], o[11]);
g.AddEdge(o[11], v[8]);
g.AddEdge(v[8], o[12]);
g.AddEdge(v[9], o[12]);
g.AddEdge(o[12], y);
}
public void Visit(ElementNode node, INode parentNode)
{
var typeref = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, Module, node));
TypeDefinition typedef = typeref.ResolveCached();
if (IsXaml2009LanguagePrimitive(node))
{
var vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(PushValueFromLanguagePrimitive(typeref, node));
Context.IL.Emit(OpCodes.Stloc, vardef);
return;
}
//if this is a MarkupExtension that can be compiled directly, compile and returns the value
var compiledMarkupExtensionName = typeref
.GetCustomAttribute(Module, (XamlCTask.xamlAssemblyName, XamlCTask.xamlNameSpace, "ProvideCompiledAttribute"))
?.ConstructorArguments?[0].Value as string;
Type compiledMarkupExtensionType;
ICompiledMarkupExtension markupProvider;
if (compiledMarkupExtensionName != null &&
(compiledMarkupExtensionType = Type.GetType(compiledMarkupExtensionName)) != null &&
(markupProvider = Activator.CreateInstance(compiledMarkupExtensionType) as ICompiledMarkupExtension) != null)
{
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
typeref = Module.ImportReference(typeref);
var vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
foreach (var prop in node.Properties)
{
if (!node.SkipProperties.Contains(prop.Key))
{
node.SkipProperties.Add(prop.Key);
}
}
node.CollectionItems.Clear();
return;
}
MethodDefinition factoryCtorInfo = null;
MethodDefinition factoryMethodInfo = null;
TypeDefinition ownerTypeOfFactoryMethod = null;
MethodDefinition parameterizedCtorInfo = null;
MethodDefinition ctorInfo = null;
if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryCtorInfo == null)
{
throw new XamlParseException(
string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node);
}
ctorInfo = factoryCtorInfo;
if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params
{
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
}
}
else if (node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
var factoryMethod = (string)(node.Properties[XmlName.xFactoryMethod] as ValueNode).Value;
factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryMethodInfo == null)
{
var typeExtensionRef = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.OnlyGetTypeExtension, Module, node));
typeExtensionRef = typeExtensionRef?.ResolveCached();
if (null != typeExtensionRef?.Resolve())
{
factoryMethodInfo = typeExtensionRef.Resolve().AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, typeref, Module, Context));
if (null != factoryMethod)
{
ownerTypeOfFactoryMethod = typeExtensionRef.ResolveCached();
}
}
}
else
{
ownerTypeOfFactoryMethod = typedef;
}
if (factoryMethodInfo == null)
{
throw new XamlParseException(
String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node);
}
Context.IL.Append(PushCtorXArguments(factoryMethodInfo, node));
}
if (ctorInfo == null && factoryMethodInfo == null)
{
parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.Parameters.All(
pd =>
pd.CustomAttributes.Any(
ca =>
ca.AttributeType.FullName ==
"Tizen.NUI.Binding.ParameterAttribute")));
}
string missingCtorParameter = null;
if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node, out missingCtorParameter))
{
ctorInfo = parameterizedCtorInfo;
// IL_0000: ldstr "foo"
Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node));
}
ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic);
if (null == ctorInfo && null == factoryMethodInfo)
{
foreach (var method in typedef.Methods)
{
if (method.IsConstructor && !method.IsStatic)
{
bool areAllParamsDefault = true;
foreach (var param in method.Parameters)
{
if (!param.HasDefault)
{
areAllParamsDefault = false;
break;
}
}
if (areAllParamsDefault)
{
if (null == ctorInfo)
{
ctorInfo = method;
}
else
{
throw new XamlParseException($"{typedef.FullName} has more than one constructor which params are all default.", node);
}
}
}
}
if (null == ctorInfo)
{
if (!typedef.IsValueType)
{
throw new XamlParseException($"{typedef.FullName} has no constructor which params are all default.", node);
}
}
else
{
factoryCtorInfo = ctorInfo;
if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params
{
Context.IL.Append(PushCtorDefaultArguments(factoryCtorInfo, node));
}
}
}
if (parameterizedCtorInfo != null && ctorInfo == null)
{
//there was a parameterized ctor, we didn't use it
throw new XamlParseException($"The Property '{missingCtorParameter}' is required to create a '{typedef.FullName}' object.", node);
}
var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module);
var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(ownerTypeOfFactoryMethod, Module);
var implicitOperatorref = typedef.Methods.FirstOrDefault(md =>
md.IsPublic &&
md.IsStatic &&
md.IsSpecialName &&
md.Name == "op_Implicit" && md.Parameters[0].ParameterType.FullName == "System.String");
if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType)
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
ValueNode vnode = null;
if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
vardef.VariableType.IsValueType)
{
//<Color>Purple</Color>
Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider[] { typedef },
node.PushServiceProvider(Context), false, true));
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
implicitOperatorref != null)
{
//<FileImageSource>path.png</FileImageSource>
var implicitOperator = Module.ImportReference(implicitOperatorref);
Context.IL.Emit(OpCodes.Ldstr, ((ValueNode)(node.CollectionItems.First())).Value as string);
Context.IL.Emit(OpCodes.Call, implicitOperator);
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (factorymethodinforef != null)
{
Context.IL.Emit(OpCodes.Call, Module.ImportReference(factorymethodinforef));
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (!typedef.IsValueType)
{
var ctor = Module.ImportReference(ctorinforef);
// IL_0001: newobj instance void class [Tizen.NUI.Xaml.UIComponents]Tizen.NUI.Xaml.UIComponents.Button::'.ctor'()
// IL_0006: stloc.0
bool isConvertValue = false;
if (node.CollectionItems.Count == 1 && node.CollectionItems.First() is ValueNode valueNode)
{
if (valueNode.CanConvertValue(Context.Module, typeref, (TypeReference)null))
{
var converterType = valueNode.GetConverterType(new ICustomAttributeProvider[] { typeref.Resolve() });
if (null != converterType)
{
isConvertValue = true;
Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider[] { typedef },
node.PushServiceProvider(Context), false, true));
}
}
}
if (false == isConvertValue)
{
Context.IL.Emit(OpCodes.Newobj, ctor);
}
Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) &&
!node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, typeref, Module, Context))
{
// IL_0008: ldloca.s 1
// IL_000a: ldc.i4.1
// IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool)
var ctor = Module.ImportReference(ctorinforef);
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
Context.IL.Emit(OpCodes.Call, ctor);
}
else
{
// IL_0000: ldloca.s 0
// IL_0002: initobj Test/Foo
Context.IL.Emit(OpCodes.Ldloca, vardef);
Context.IL.Emit(OpCodes.Initobj, Module.ImportReference(typedef));
}
if (null != XamlCTask.BaseTypeDefiniation && typedef.InheritsFromOrImplements(XamlCTask.BaseTypeDefiniation))
{
var field = XamlCTask.BaseTypeDefiniation.Properties.SingleOrDefault(fd => fd.Name == "IsCreateByXaml");
if (field == null)
{
return;
}
ValueNode value = new ValueNode("true", node.NamespaceResolver);
Set(Context.Variables[node], "IsCreateByXaml", value, null);
}
if (typeref.FullName == "Tizen.NUI.Xaml.ArrayExtension")
{
var visitor = new SetPropertiesVisitor(Context);
foreach (var cnode in node.Properties.Values.ToList())
{
cnode.Accept(visitor, node);
}
foreach (var cnode in node.CollectionItems)
{
cnode.Accept(visitor, node);
}
markupProvider = new ArrayExtension();
var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
Context.Body.Variables.Add(vardef);
Context.IL.Append(il);
Context.IL.Emit(OpCodes.Stloc, vardef);
//clean the node as it has been fully exhausted
foreach (var prop in node.Properties)
{
if (!node.SkipProperties.Contains(prop.Key))
{
node.SkipProperties.Add(prop.Key);
}
}
return;
}
}
}
public ProgramGraph CreateUnrolledProgramGraph(int k)
{
ProgramGraph g = new ProgramGraph();
ValueNode[] xp = new ValueNode[k + 1];
ValueNode[] yp = new ValueNode[k + 1];
ValueNode[] y = new ValueNode[k + 1];
ValueNode[] x = new ValueNode[k + 1];
for (int i = 0; i < k + 1; i++) {
xp[i] = new TestRegisterNode("xp[" + i + "]", Datatype.AddressValue);
yp[i] = new TestRegisterNode("yp[" + i + "]", Datatype.AddressValue);
y[i] = new TestRegisterNode("y[" + i + "]", Datatype.FloatValue);
x[i] = new TestRegisterNode("x[" + i + "]", Datatype.FloatValue);
g.AddNode(xp[i]);
g.AddNode(yp[i]);
g.AddNode(x[i]);
g.AddNode(y[i]);
}
ValueNode pc0 = new FloatMemoryNode("c0");
ValueNode pc1 = new FloatMemoryNode("c1");
ValueNode pc2 = new FloatMemoryNode("c2");
OperationNode lc0 = new LoadOperationNode();
OperationNode lc1 = new LoadOperationNode();
OperationNode lc2 = new LoadOperationNode();
ValueNode c0 = new FloatRegisterNode();
ValueNode c1 = new FloatRegisterNode();
ValueNode c2 = new FloatRegisterNode();
g.AddNode(pc0); g.AddNode(pc1); g.AddNode(pc2);
g.AddNode(lc0); g.AddNode(lc1); g.AddNode(lc2);
g.AddNode(c0); g.AddNode(c1); g.AddNode(c2);
g.AddEdge(pc0, lc0); g.AddEdge(lc0, c0);
g.AddEdge(pc1, lc1); g.AddEdge(lc1, c1);
g.AddEdge(pc2, lc2); g.AddEdge(lc2, c2);
for (int i = 0; i < k; i++) {
CreateSingleLoop(
g, xp[i], yp[i], x[i], y[i], c0, c1, c2,
xp[i + 1], yp[i + 1], x[i + 1], y[i + 1]);
}
g.InitInputValues();
g.InitOutputValues();
g.OutputValues.Add(x[k]);
g.OutputValues.Add(y[k]);
x[k].OutputFlag = true;
y[k].OutputFlag = true;
g.CyclicDependencies[xp[0]] = xp[k];
g.CyclicDependencies[xp[k]] = xp[0];
g.CyclicDependencies[yp[0]] = yp[k];
g.CyclicDependencies[yp[k]] = yp[0];
g.CyclicDependencies[y[0]] = y[k];
g.CyclicDependencies[y[k]] = y[0];
g.CyclicDependencies[x[0]] = x[k];
g.CyclicDependencies[x[k]] = x[0];
return g;
}
public static bool CanConvertValue(this ValueNode node, ILContext context, TypeReference targetTypeRef, TypeReference typeConverter)
{
var str = (string)node.Value;
var module = context.Body.Method.Module;
//If there's a [TypeConverter], assume we can convert
if (typeConverter != null && str != null)
{
return(true);
}
//check if it's assignable from a string
if (targetTypeRef.ResolveCached().FullName == "System.Nullable`1")
{
targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0];
}
if (targetTypeRef.ResolveCached().BaseType != null && targetTypeRef.ResolveCached().BaseType.FullName == "System.Enum")
{
return(true);
}
if (targetTypeRef.FullName == "System.Char")
{
return(true);
}
if (targetTypeRef.FullName == "System.SByte")
{
return(true);
}
if (targetTypeRef.FullName == "System.Int16")
{
return(true);
}
if (targetTypeRef.FullName == "System.Int32")
{
return(true);
}
if (targetTypeRef.FullName == "System.Int64")
{
return(true);
}
if (targetTypeRef.FullName == "System.Byte")
{
return(true);
}
if (targetTypeRef.FullName == "System.UInt16")
{
return(true);
}
if (targetTypeRef.FullName == "System.UInt32")
{
return(true);
}
if (targetTypeRef.FullName == "System.UInt64")
{
return(true);
}
if (targetTypeRef.FullName == "System.Single")
{
return(true);
}
if (targetTypeRef.FullName == "System.Double")
{
return(true);
}
if (targetTypeRef.FullName == "System.Boolean")
{
return(true);
}
if (targetTypeRef.FullName == "System.TimeSpan")
{
return(true);
}
if (targetTypeRef.FullName == "System.DateTime")
{
return(true);
}
if (targetTypeRef.FullName == "System.String")
{
return(true);
}
if (targetTypeRef.FullName == "System.Object")
{
return(true);
}
if (targetTypeRef.FullName == "System.Decimal")
{
return(true);
}
var implicitOperator = module.TypeSystem.String.GetImplicitOperatorTo(targetTypeRef, module);
if (implicitOperator != null)
{
return(true);
}
return(false);
}
public void Visit(ValueNode node, INode parentNode)
{
}
public string Visit(ValueNode node) => node.Value.ToString();
internal OpContains(FieldNode field, ValueNode valueNode)
: base(field, valueNode)
{
}
internal override ValueNode CreateSerializerOverride(ValueNode parent)
{
return(new CustomValueNode(parent, Name, this));
}
