public PMNameNode(ExpressionNode node, string tokenString, ExpressionContext context) : base(node, tokenString, context) { string[] parts = Name.Split('.'); if (parts.Length == 3) { isAttribute = true; ObjectName = (PMObjectType)Enum.Parse(typeof(PMObjectType), parts[0], true); FieldName = parts[2].Trim('[',']').Trim(); } else if (parts.Length == 2) { ObjectName = (PMObjectType)Enum.Parse(typeof(PMObjectType), parts[0], true); if (parts[1].Trim().EndsWith("_Attributes")) { isAttribute = true; FieldName = parts[1].Substring(0, parts[1].Length - 11); } else FieldName = parts[1]; } else { ObjectName = PMObjectType.PMTran; FieldName = Name; } }
public ForStatementNode(ExpressionNode variable, ExpressionNode initialValue, ExpressionNode finalValue, List<StatementNode> list) { Variable = variable; InitialValue = initialValue; FinalValue = finalValue; Code = list; }
public IList<Person> FindPersons(ExpressionNode query) { try { var expression = query.ToBooleanExpression<Person>(); return _persons.Where(expression.Compile()).ToList(); } catch (Exception ex) { Console.Error.WriteLine(ex); return new List<Person>(); } }
public static ExpressionNode GenerateEmotionalExpression(float arousal, float valence, float transitionTime = 1f) { var offset = new ExpressionNode(); offset.Name = string.Format("{0} {1}", arousal, valence); offset.TransitionTime = transitionTime; offset.RevertTime = -1f; offset.HoldTime = 0f; offset.EaseIn = 0; offset.EaseOut = 0; offset.Weight = 0.7f; string valenceExpr = (valence < Config.Neutral ? "unhappy" : "happy"); string arousalExpr = (arousal < Config.Neutral ? "calm" : "surprised"); float v = Mathf.Abs(valence - Config.Neutral); float a = Mathf.Abs(arousal - Config.Neutral); Vector3 valenceWeight = new Vector3(v, v, v); Vector3 arousalWeight = new Vector3(a, a, a); offset.GoalPos = new Dictionary<string, Vector3>(); if (ExpressionLibrary.Contains(valenceExpr)) { var valGoal = new Dictionary<string, Vector3>(ExpressionLibrary.Get(valenceExpr)); var aroGoal = new Dictionary<string, Vector3>(ExpressionLibrary.Get(arousalExpr)); float u = 0.8f; float l = -0.02f; foreach(var key in valGoal.Keys) { Vector3 tinyError = new Vector3(Random.Range(l, u), Random.Range(l, u), Random.Range(l, u)); tinyError.Scale(valenceWeight); var vec = Vector3.Scale(valGoal[key], valenceWeight); if (offset.GoalPos.ContainsKey(key)) offset.GoalPos[key] = vec + Vector3.Scale(vec, tinyError); else offset.GoalPos.Add(key, vec + Vector3.Scale(valGoal[key], tinyError)); } foreach (var key in aroGoal.Keys) { Vector3 tinyError = new Vector3(Random.Range(l, u), Random.Range(l, u), Random.Range(l, u)); tinyError.Scale(arousalWeight); var vec = Vector3.Scale(aroGoal[key], arousalWeight); if (offset.GoalPos.ContainsKey(key)) offset.GoalPos[key] += vec + Vector3.Scale(vec, tinyError); else offset.GoalPos.Add(key, vec + Vector3.Scale(aroGoal[key], tinyError)); } } else { throw new UnityException("what the f**k"); } return offset; }
public object Select(object o) { if (string.IsNullOrEmpty(MemberName)) { return o; } if (_expressionNode == null) { _expressionNode = ExpressionNodeBuilder.Build(MemberName); _memberValueNode = _expressionNode; while (_memberValueNode.Next != null) { _memberValueNode = _memberValueNode.Next; } } _expressionNode.Target = new WeakReference(o); object result = _memberValueNode.CurrentValue.Target; _expressionNode.Target = null; if (result == AvaloniaProperty.UnsetValue) { return null; } else if (result is BindingError) { return null; } return result; }
public ExpressionStatement(ExpressionNode expr) { this.expr = expr; }
public void visitExpression(ExpressionNode node) { node.getChildren()[0].accept(this); }
/// <summary> /// Initializes a new instance of the <see cref="RegexMatchFunctionNode"/> class. /// </summary> /// <param name="parameter1"> /// The parameter 1. /// </param> /// <param name="parameter2"> /// The parameter 2. /// </param> public RegexMatchFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2) : base(ExpressionNodeType.RegexMatch, parameter1, parameter2) { }
public Vertex(ExpressionNode expression) { Expression = expression; }
/// <summary> /// Initializes a new instance of <see cref="SumFunctionNode"/> class. /// </summary> /// <param name="parameter1"></param> /// <param name="parameter2"></param> public SumFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2) : base(ExpressionNodeType.Sum, parameter1, parameter2) { }
private void AssertIsIndexer(ExpressionNode node, params object[] args) { Assert.IsType<IndexerNode>(node); var e = (IndexerNode)node; Assert.Equal(e.Arguments.ToArray(), args.ToArray()); }
public static NCNeededRunBefore GetNeededRunBefore(Command Command, ExpressionNode Node) { //var Identifiers = GetUsedCommandIdentifiers(Command, Node); return(new NCNeededRunBefore(Node /*, Identifiers*/)); }
/// <summary> /// Initializes a new instance of <see cref="GoingDownFunctionNode"/> class. /// </summary> /// <param name="parameter1">SPC type field which stores SPC preferences as xml</param> /// <param name="parameter2">Size of subgroup in samples</param> /// <param name="parameter3">Number of subgroups in a row to satisfy a condition</param> /// <param name="parameter4">Chart type</param> public SPC_GoingDownFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2, ExpressionNode parameter3, ExpressionNode parameter4) : base(ExpressionNodeType.GoingDown, parameter1, parameter2, parameter3, parameter4) { }
//public Identifier[] Identifiers; public NCNeededRunBefore(ExpressionNode Node /*, Identifier[] Identifiers*/) { this.Node = Node; //this.Identifiers = Identifiers; }
public static ExpressionNode FlattenIndices(PluginRoot Plugin, ExpressionNode[] Indices, ExpressionNode[] Dimensions, CodeString Code, Identifier TempVarType = null) { if (Dimensions.Length == 1) { return(Indices[0]); } var Ret = (ExpressionNode)null; var MulVar = (Identifier)null; var Container = Plugin.Container; var State = Plugin.State; if (Dimensions.Length >= 2) { var NCPlugin = Plugin.GetPlugin <NCPlugin>(); var DeclContainer = NCPlugin.DeclContainer; MulVar = DeclContainer.CreateAndDeclareVariable(State.AutoVarName, TempVarType); if (MulVar == null) { return(null); } } for (var i = Dimensions.Length - 1; i >= 0; i--) { var Chi = Indices[i]; var LinkedNode = (LinkedExprNode)null; if (MulVar != null && i != 1) { ExpressionNode[] AssignmentCh; if (i == Dimensions.Length - 1) { var Dst = Plugin.NewNode(new IdExpressionNode(MulVar, Code)); if (Dst == null) { return(null); } AssignmentCh = new ExpressionNode[] { Dst, Dimensions[i] }; } else { var Dst = Plugin.NewNode(new IdExpressionNode(MulVar, Code)); var MulSrc = Plugin.NewNode(new IdExpressionNode(MulVar, Code)); if (Dst == null || MulSrc == null) { return(null); } var MulCh = new ExpressionNode[] { MulSrc, Dimensions[i] }; var MulNode = Plugin.NewNode(new OpExpressionNode(Operator.Multiply, MulCh, Code)); if (MulNode == null) { return(null); } AssignmentCh = new ExpressionNode[] { Dst, MulNode }; } var Assignment = Plugin.NewNode(new OpExpressionNode(Operator.Assignment, AssignmentCh, Code)); if (Assignment == null) { return(null); } LinkedNode = new LinkedExprNode(Assignment, LinkedNodeFlags.NotRemovable); } if (MulVar != null && i != Dimensions.Length - 1) { var MulNode = Plugin.NewNode(new IdExpressionNode(MulVar, Code)); if (MulNode == null) { return(null); } var MulCh = new ExpressionNode[] { Chi, MulNode }; Chi = Plugin.NewNode(new OpExpressionNode(Operator.Multiply, MulCh, Code)); if (Chi == null) { return(null); } } if (Ret != null) { var AddCh = new ExpressionNode[] { Ret, Chi }; var AddNode = new OpExpressionNode(Operator.Add, AddCh, Code); if (LinkedNode != null) { AddNode.LinkedNodes.Add(LinkedNode); } Ret = Plugin.NewNode(AddNode); if (Ret == null) { return(null); } } else { Ret = Chi; if (LinkedNode != null) { Ret.LinkedNodes.Add(LinkedNode); } } } return(Ret); }
protected virtual void VisitValueExpression( XElement element, XAttribute attribute, MSBuildElementSyntax resolvedElement, MSBuildAttributeSyntax resolvedAttribute, ITypedSymbol valueType, MSBuildValueKind inferredKind, ExpressionNode node) { }
public LessThanOrEqualNode(ExpressionNode lhs, ExpressionNode rhs) : base(lhs, rhs) { }
public InvocationExpressionNode WithExpression(ExpressionNode kIdentifierExpression) { kIdentifierExpression.Parent = this; Expression = kIdentifierExpression; return(this); }
/// <summary> /// Initializes a new instance of the <see cref="GetArrayItemFunctionNode"/> class. /// </summary> /// <param name="parameter1"> /// The parameter 1. /// </param> /// <param name="parameter2"> /// The parameter 2. /// </param> /// <param name="elementType"> /// The element type. /// </param> public GetArrayItemFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2, NodeDataType elementType) : base(ExpressionNodeType.GetArrayItem, parameter1, parameter2) { _elementType = elementType; }
public static void GetExpressionRunBefores(Command Command, ExpressionNode Node, List <NCNeededRunBefore> Out) { for (var i = 0; i < Node.LinkedNodes.Count; i++) { GetExpressionRunBefores(Command, Node.LinkedNodes[i].Node, Out); } if (Node.Children != null) { for (var i = 0; i < Node.Children.Length; i++) { GetExpressionRunBefores(Command, Node.Children[i], Out); } } if (Node is OpExpressionNode) { var OpNode = Node as OpExpressionNode; var Op = OpNode.Operator; var Ch = OpNode.Children; if (Op == Operator.Cast) { if (Node.CheckingMode == CheckingMode.Checked) { var NFrom = GetEquivalentNumberType(Ch[0].Type); var NTo = GetEquivalentNumberType(Node.Type); if (NFrom != null && NTo != null) { if (NFrom.Size > NTo.Size || (NFrom is SignedType && NTo is UnsignedType)) { Out.Add(GetNeededRunBefore(Command, Ch[0])); } } } } else if (IsOverflowableOp(Op)) { if (Node.CheckingMode == CheckingMode.Checked) { if (GetEquivalentNumberType(Node.Type) != null) { Out.Add(GetNeededRunBefore(Command, Node)); } } } else if (Operators.IsNewOp(Op)) { if (!Node.LinkedNodes.TrueForAll(x => !(x.Node is InitializationNode))) {/* * var IdList = new List<Identifier>(); * for (var i = 0; i < Node.LinkedNodes.Count; i++) * { * var LNode = Node.LinkedNodes[i].Node; * if (LNode is InitializationNode) * LNode.ForEachChildren(x => GetUsedCommandIdentifiers(Command, x, IdList)); * } */ Out.Add(new NCNeededRunBefore(Node /*, IdList.ToArray()*/)); } } } }
/// <summary> /// Initializes a new instance of <see cref="DateWeekFunctionNode"/> class. /// </summary> /// <param name="parameter"></param> public DateWeekFunctionNode(ExpressionNode parameter) : base(ExpressionNodeType.DateWeek, parameter) { }
public static NCExpressionRunBefores GetExpressionRunBefores(Command Command, ExpressionNode Node) { var Ret = new NCExpressionRunBefores(); var List = new List <NCNeededRunBefore>(); GetExpressionRunBefores(Command, Node, List); Ret.NeededRunBefores = List.ToArray(); return(Ret); }
/// <summary> /// Initializes a new instance of the <see cref="BitwiseOrFunctionNode"/> class. /// </summary> /// <param name="parameter1">The first parameter.</param> /// <param name="parameter2">The second parameter.</param> public BitwiseOrFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2) : base(ExpressionNodeType.BitwiseOr, parameter1, parameter2) { }
public ExpressionNode(Expression expression, ExpressionNode parent) { Expression = expression; Parent = parent; }
/// <summary> /// Initializes a new instance of <see cref="AppraiserPartAverageFunctionNode"/> class. /// </summary> /// <param name="parameter1">Gage R&R type field</param> /// <param name="parameter2">Appraiser code</param> /// <param name="parameter3">Part name</param> public GageRR_AppraiserPartAverageFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2, ExpressionNode parameter3) : base(ExpressionNodeType.AppraiserPartAverage, parameter1, parameter2, parameter3) { }
protected override void Visit(ExpressionNode node) { Nodes.Add(node); }
/// <summary> /// Initializes a new instance of the <see cref="FormatValueFunctionNode"/> class. /// </summary> /// <param name="parameter1"> /// The parameter 1. /// </param> /// <param name="parameter2"> /// The parameter 2. /// </param> /// <param name="dataType"> /// The data type. /// </param> public FormatValueFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2, NodeDataType dataType) : base(ExpressionNodeType.FormatValue, parameter1, parameter2) { DataType = dataType; }
public override void Visit(ExpressionNode node) { parent.Expressions.Add(node); }
/// <summary> /// Initializes a new instance of <see cref="BelowCenterLineFunctionNode"/> class. /// </summary> /// <param name="parameter1">SPC type field which stores SPC preferences as xml</param> /// <param name="parameter2">Size of subgroup in samples</param> /// <param name="parameter3">Number of subgroups in a row to satisfy a condition</param> /// <param name="parameter4">Chart type</param> public SPC_BelowCenterLineFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2, ExpressionNode parameter3, ExpressionNode parameter4) : base(ExpressionNodeType.BelowCenterLine, parameter1, parameter2, parameter3, parameter4) { }
/// <summary> /// Initializes a new instance of <see cref="HasRemovedItemsFunctionNode"/> class. /// </summary> /// <param name="parameter"> </param> public HasRemovedItemsFunctionNode(ExpressionNode parameter) : base(ExpressionNodeType.HasRemovedItems, parameter) { }
public static IEnumerable <string> EvaluateExpressionAsPaths(ExpressionNode expression, MSBuildRootDocument doc, int skipEndChars = 0, string baseDir = null) { baseDir = baseDir ?? Path.GetDirectoryName(doc.Filename); if (expression == null) { yield return(baseDir); yield break; } if (expression is ListExpression list) { expression = list.Nodes[list.Nodes.Count - 1]; } if (expression is ExpressionText lit) { if (lit.Length == 0) { yield return(baseDir); yield break; } var path = TrimEndChars(lit.GetUnescapedValue()); if (string.IsNullOrEmpty(path)) { yield return(baseDir); yield break; } //FIXME handle encoding if (MSBuildEscaping.FromMSBuildPath(path, baseDir, out var res)) { yield return(res); } yield break; } if (!(expression is ConcatExpression expr)) { yield break; } //FIXME evaluate directly without the MSBuildEvaluationContext var sb = new StringBuilder(); for (int i = 0; i < expr.Nodes.Count; i++) { var node = expr.Nodes[i]; if (node is ExpressionText l) { var val = l.GetUnescapedValue(); if (i == expr.Nodes.Count - 1) { val = TrimEndChars(val); } sb.Append(val); } else if (node is ExpressionProperty p) { sb.Append($"$({p.Name})"); } else { yield break; } } foreach (var variant in doc.FileEvaluationContext.EvaluatePathWithPermutation(sb.ToString(), baseDir)) { yield return(variant); } string TrimEndChars(string s) => s.Substring(0, Math.Min(s.Length, s.Length - skipEndChars)); }
/// <summary> /// Initializes a new instance of <see cref="FailedPercentFunctionNode"/> class. /// </summary> /// <param name="parameter1">SPC type field which stores SPC preferences as xml</param> /// <param name="parameter2">Size of subgroup in samples</param> /// <param name="parameter3">Percent of samples failed in subgroup (1 = 1%)</param> /// <param name="parameter4">Chart type</param> public SPC_FailedPercentFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2, ExpressionNode parameter3, ExpressionNode parameter4) : base(ExpressionNodeType.FailedPercent, parameter1, parameter2, parameter3, parameter4) { }
protected override NameNode CreateNameNode(ExpressionNode node, string tokenString) { return(new CTNameNode(node, tokenString, Context)); }
static void AssertEqual(ExpressionNode expected, ExpressionNode actual, int expectedOffset) { if (expected == null) { Assert.IsNull(actual); return; } if (actual is ExpressionError err && !(expected is ExpressionError)) { Assert.Fail($"Unexpected ExpressionError: {err.Kind} @ {err.Offset}"); } Assert.That(actual, Is.TypeOf(expected.GetType())); switch (actual) { case Expression expr: var expectedExpr = (Expression)expected; Assert.AreEqual(expectedExpr.Nodes.Count, expr.Nodes.Count); for (int i = 0; i < expr.Nodes.Count; i++) { AssertEqual(expectedExpr.Nodes [i], expr.Nodes [i], expectedOffset); } break; case ExpressionText literal: var expectedLit = (ExpressionText)expected; Assert.AreEqual(expectedLit.Value, literal.Value); Assert.AreEqual(expectedLit.IsPure, literal.IsPure); break; case ExpressionProperty prop: var expectedProp = (ExpressionProperty)expected; AssertEqual(expectedProp.Expression, prop.Expression, expectedOffset); break; case ExpressionItem item: var expectedItem = (ExpressionItem)expected; AssertEqual(expectedItem.Expression, item.Expression, expectedOffset); break; case ExpressionMetadata meta: var expectedMeta = (ExpressionMetadata)expected; Assert.AreEqual(expectedMeta.MetadataName, meta.MetadataName); Assert.AreEqual(expectedMeta.ItemName, meta.ItemName); break; case ExpressionItemName itemName: var expectedItemName = (ExpressionItemName)expected; Assert.AreEqual(expectedItemName.Name, itemName.Name); break; case ExpressionPropertyName propName: var expectedPropName = (ExpressionPropertyName)expected; Assert.AreEqual(expectedPropName.Name, propName.Name); break; case ExpressionFunctionName funcName: var expectedFuncName = (ExpressionFunctionName)expected; Assert.AreEqual(expectedFuncName.Name, funcName.Name); break; case ExpressionPropertyFunctionInvocation propInv: var expectedPropInv = (ExpressionPropertyFunctionInvocation)expected; AssertEqual(expectedPropInv.Function, propInv.Function, expectedOffset); AssertEqual(expectedPropInv.Target, propInv.Target, expectedOffset); AssertEqual(expectedPropInv.Arguments, propInv.Arguments, expectedOffset); break; case ExpressionItemFunctionInvocation itemInv: var expectedItemInv = (ExpressionItemFunctionInvocation)expected; AssertEqual(expectedItemInv.Function, itemInv.Function, expectedOffset); AssertEqual(expectedItemInv.Target, itemInv.Target, expectedOffset); AssertEqual(expectedItemInv.Arguments, itemInv.Arguments, expectedOffset); break; case ExpressionItemTransform itemTransform: var expectedItemTransform = (ExpressionItemTransform)expected; AssertEqual(expectedItemTransform.Transform, itemTransform.Transform, expectedOffset); AssertEqual(expectedItemTransform.Target, itemTransform.Target, expectedOffset); AssertEqual(expectedItemTransform.Separator, itemTransform.Separator, expectedOffset); break; case ExpressionArgumentList argList: var expectedArgList = (ExpressionArgumentList)expected; Assert.AreEqual(expectedArgList.Arguments.Count, argList.Arguments.Count); for (int i = 0; i < argList.Arguments.Count; i++) { AssertEqual(expectedArgList.Arguments[i], argList.Arguments[i], expectedOffset); } break; case ExpressionArgumentLiteral argLiteral: var expectedArgLiteral = (ExpressionArgumentLiteral)expected; Assert.AreEqual(expectedArgLiteral.Kind, argLiteral.Kind); Assert.AreEqual(expectedArgLiteral.Value, argLiteral.Value); break; case ExpressionPropertyRegistryValue regVal: var expectedRegVal = (ExpressionPropertyRegistryValue)expected; Assert.AreEqual(expectedRegVal.RegistryReference, regVal.RegistryReference); break; default: throw new Exception($"Unsupported node kind {actual.GetType()}"); } Assert.AreEqual(expected.Length, actual.Length); Assert.AreEqual(expected.Offset + expectedOffset, actual.Offset); }
/// <summary> /// Initializes a new instance of <see cref="DateMonthFunctionNode"/> class. /// </summary> /// <param name="parameter"></param> public DateMonthFunctionNode(ExpressionNode parameter) : base(ExpressionNodeType.DateMonth, parameter) { }
public override ExpressionNode Resolve(IExpressionVisitor visitor, ExpressionNode caller, ExpressionNode[] arguments) { return(new StatusNode(Status.Error, arguments.FirstOrDefault())); }
/// <summary> /// Initializes a new instance of <see cref="IsLessFunctionNode"/> class. /// </summary> /// <param name="parameter1"></param> /// <param name="parameter2"></param> public IsLessFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2) : base(ExpressionNodeType.IsLess, parameter1, parameter2) { }
public override ExpressionNode Resolve(IExpressionVisitor visitor, ExpressionNode caller, ExpressionNode[] arguments) { return(new TableKeyAccessNode(caller, new ConstantValueNode(DataValueType.String, "err"))); }
/// <summary> /// Initializes a new instance of <see cref="TrimFunctionNode"/> class. /// </summary> /// <param name="parameter"></param> public TrimFunctionNode(ExpressionNode parameter) : base(ExpressionNodeType.Trim, parameter) { }
public override ExpressionNode Resolve(IExpressionVisitor visitor, ExpressionNode caller, ExpressionNode[] arguments) { return(new CastNode(DataValueType.Float, arguments.First())); }
/// <summary> /// Initializes a new instance of <see cref="ZoneAorBeyondFunctionNode"/> class. /// </summary> /// <param name="parameter1">SPC type field which stores SPC preferences as xml</param> /// <param name="parameter2">Size of subgroup in samples</param> /// <param name="parameter3">Number of subgroups to satisfy a condition</param> /// <param name="parameter4">Number of a larger subset of subgroups which includes subgroups from parameter3</param> /// <param name="parameter5">Chart type</param> public SPC_ZoneAorBeyondFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2, ExpressionNode parameter3, ExpressionNode parameter4, ExpressionNode parameter5) : base(ExpressionNodeType.ZoneAorBeyond, parameter1, parameter2, parameter3, parameter4, parameter5) { }
public override ExpressionNode Resolve(IExpressionVisitor visitor, ExpressionNode caller, ExpressionNode[] arguments) { return(new StatusNode(Status.Ok)); }
/// <summary> /// Initializes a new instance of <see cref="AddFunctionNode"/> class. /// </summary> /// <param name="parameter1"></param> /// <param name="parameter2"></param> public AddFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2) :base(ExpressionNodeType.Add, parameter1, parameter2) { }
public GridValueNode(ExpressionNode first, ExpressionNode second, IdentifierValueNode member) { FirstD = first; SecondD = second; Member = member; }
public void SetChildren(ExpressionNode left, ExpressionNode right) { Left = left; Right = right; }
public AndExpression(ExpressionNode leftExpression, ExpressionNode rightExpression, int line, int letter) : base(new List<ExpressionNode> { leftExpression, rightExpression }, line, letter) {}
public MultiplicationNode(ExpressionNode leftNode, ExpressionNode rightNode) : base(leftNode, rightNode) { }
public override dynamic Visit(ExpressionNode node) { return(null); }
/// <summary> /// Initializes a new instance of <see cref="AreEqualFunctionNode"/> class. /// </summary> /// <param name="parameter1"></param> /// <param name="parameter2"></param> public AreEqualFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2) : base(ExpressionNodeType.AreEqual, parameter1, parameter2) { }
protected override void VisitValueExpression( XElement element, XAttribute attribute, MSBuildElementSyntax resolvedElement, MSBuildAttributeSyntax resolvedAttribute, ValueInfo info, MSBuildValueKind kind, ExpressionNode node) { var nodeAtOffset = node.Find(offset); switch (nodeAtOffset) { case ExpressionItemName ei: rr.ReferenceKind = MSBuildReferenceKind.Item; rr.ReferenceOffset = ei.Offset; rr.ReferenceLength = ei.Name.Length; rr.Reference = ei.Name; break; case ExpressionPropertyName propName: rr.ReferenceKind = MSBuildReferenceKind.Property; rr.ReferenceOffset = propName.Offset; rr.Reference = propName.Name; rr.ReferenceLength = propName.Length; break; case ExpressionMetadata em: if (em.ItemName == null || offset >= em.MetadataNameOffset) { rr.ReferenceKind = MSBuildReferenceKind.Metadata; rr.ReferenceOffset = em.MetadataNameOffset; rr.Reference = (em.GetItemName(), em.MetadataName); rr.ReferenceLength = em.MetadataName.Length; } else { rr.ReferenceKind = MSBuildReferenceKind.Item; rr.ReferenceOffset = em.ItemNameOffset; rr.Reference = em.ItemName; rr.ReferenceLength = em.ItemName.Length; } break; case ExpressionFunctionName name: rr.ReferenceOffset = name.Offset; rr.ReferenceLength = name.Name.Length; switch (name.Parent) { case ExpressionItemNode _: rr.ReferenceKind = MSBuildReferenceKind.ItemFunction; rr.Reference = name.Name; break; case ExpressionPropertyFunctionInvocation prop: { if (prop.Target is ExpressionClassReference classRef) { rr.ReferenceKind = MSBuildReferenceKind.StaticPropertyFunction; rr.Reference = (classRef.Name, name.Name); } else if (prop.Target is ExpressionPropertyNode propNode) { var type = functionTypeProvider?.ResolveType(propNode) ?? MSBuildValueKind.Unknown; rr.ReferenceKind = MSBuildReferenceKind.PropertyFunction; rr.Reference = (type, name.Name); } break; } case ExpressionConditionFunction _: rr.ReferenceKind = MSBuildReferenceKind.ConditionFunction; rr.Reference = name.Name; break; } break; case ExpressionClassReference cr: if (!string.IsNullOrEmpty(cr.Name)) { if (cr.Parent is ExpressionArgumentList) { rr.ReferenceKind = MSBuildReferenceKind.Enum; } else if (cr.Parent is ExpressionPropertyFunctionInvocation) { rr.ReferenceKind = MSBuildReferenceKind.ClassName; } else { break; } rr.ReferenceOffset = cr.Offset; rr.Reference = cr.Name; rr.ReferenceLength = cr.Length; } break; case ExpressionText lit: kind = kind.GetScalarType(); if (lit.IsPure) { VisitPureLiteral(element, info, kind, lit); if (kind == MSBuildValueKind.TaskOutputParameterName) { rr.ReferenceKind = MSBuildReferenceKind.TaskParameter; rr.ReferenceOffset = lit.Offset; rr.ReferenceLength = lit.Value.Length; rr.Reference = (element.ParentElement.Name.Name, lit.Value); break; } } switch (kind) { case MSBuildValueKind.File: case MSBuildValueKind.FileOrFolder: case MSBuildValueKind.ProjectFile: case MSBuildValueKind.TaskAssemblyFile: var pathNode = lit.Parent as ConcatExpression ?? (ExpressionNode)lit; var path = MSBuildNavigation.GetPathFromNode(pathNode, (MSBuildRootDocument)Document); if (path != null) { rr.ReferenceKind = MSBuildReferenceKind.FileOrFolder; rr.ReferenceOffset = path.Offset; rr.ReferenceLength = path.Length; rr.Reference = path.Paths; } break; } break; } }
private void AssertIsProperty(ExpressionNode node, string name) { Assert.IsType<PropertyAccessorNode>(node); var p = (PropertyAccessorNode)node; Assert.Equal(name, p.PropertyName); }
public WhileNode(SourcePosition position, ExpressionNode condition, StatementNode code) : base(position) { Condition = condition; Code = code; }
private List<ExpressionNode> ToList(ExpressionNode node) { var result = new List<ExpressionNode>(); while (node != null) { result.Add(node); node = node.Next; } return result; }
public ExpressionNode(Operator operatorMap, ExpressionNode right) { this.Operator = operatorMap; this.Right = right; }
/// <summary> /// Initializes a new instance of <see cref="AppraiserXBarFunctionNode"/> class. /// </summary> /// <param name="parameter1">Gage R&R type field</param> /// <param name="parameter2">Appraiser code</param> public GageRR_AppraiserXBarFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2) : base(ExpressionNodeType.AppraiserXBar, parameter1, parameter2) { }
protected virtual void Add(OperatorTypes operatorType, ExpressionNode expressionNode) { if (expressionNode == null) { return; } var oldLast = _last; var oper = GetOperatorMap(operatorType); if (_first == null) { _first = _last = expressionNode; } else if (expressionNode.IsUnary) { if (_last.IsUnary) { _last = new ExpressionNode(oper, _last, expressionNode); } else if (oper.Precidence <= _last.Operator.Precidence) { _last = _last.Right = new ExpressionNode(oper, _last.Right, expressionNode); oldLast = null; } else { _last.Set(new ExpressionNode(oper, _last.Clone(), expressionNode)); } } else if (oper.Precidence <= expressionNode.Operator.Precidence && oper.OperatorType != OperatorTypes.IndexOf) { if (_last.IsUnary) { _last.Set(new ExpressionNode( oper, _last.Clone(), expressionNode.Left )); } else { _last = _last.Right = new ExpressionNode( oper, _last.Right, expressionNode.Left ); } if (_first == oldLast) { _first = _last; } Add(expressionNode.Operator.OperatorType, expressionNode.Right); return; } else if (_first == _last) { _first = _last = new ExpressionNode(oper, _last, expressionNode); } else { _last.Set(new ExpressionNode(oper, _last.Clone(), expressionNode)); } if (_first == oldLast) { _first = _last; } }
protected override void Visit(ExpressionNode expressionNode) { }
public void Set(ExpressionNode expressionNode) { this.Operator = Operator.Noop; this.Expression = null; this.Right = expressionNode; }
/// <summary> /// Initializes a new instance of <see cref="ConcatFunctionNode"/> class. /// </summary> /// <param name="parameter1"></param> /// <param name="parameter2"></param> public ConcatFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2) :base(ExpressionNodeType.Concat, parameter1, parameter2) { }
public virtual ASTNode Transform(ExpressionNode item) { return(item); }