コード例 #1
0
		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;
			}
		}
コード例 #2
0
 public ForStatementNode(ExpressionNode variable, ExpressionNode initialValue, ExpressionNode finalValue, List<StatementNode> list)
 {
     Variable = variable;
     InitialValue = initialValue;
     FinalValue = finalValue;
     Code = list;
 }
コード例 #3
0
 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>();
     }
 }
コード例 #4
0
ファイル: FaceControllerII.cs プロジェクト: HASParty/ggpai
    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;
    }
コード例 #5
0
        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;
        }
コード例 #6
0
 public ExpressionStatement(ExpressionNode expr)
 {
     this.expr = expr;
 }
コード例 #7
0
 public void visitExpression(ExpressionNode node)
 {
     node.getChildren()[0].accept(this);
 }
コード例 #8
0
 /// <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)
 {   
 }
コード例 #9
0
ファイル: Vertex.cs プロジェクト: Maciej-Poleski/KO-Nicodem
 public Vertex(ExpressionNode expression)
 {
     Expression = expression;
 }
コード例 #10
0
ファイル: SumFunctionNode.cs プロジェクト: mparsin/Elements
 /// <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)
 {
 }
コード例 #11
0
        private void AssertIsIndexer(ExpressionNode node, params object[] args)
        {
            Assert.IsType<IndexerNode>(node);

            var e = (IndexerNode)node;
            Assert.Equal(e.Arguments.ToArray(), args.ToArray());
        }
コード例 #12
0
 public static NCNeededRunBefore GetNeededRunBefore(Command Command, ExpressionNode Node)
 {
     //var Identifiers = GetUsedCommandIdentifiers(Command, Node);
     return(new NCNeededRunBefore(Node /*, Identifiers*/));
 }
コード例 #13
0
 /// <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)
 {
 }
コード例 #14
0
        //public Identifier[] Identifiers;

        public NCNeededRunBefore(ExpressionNode Node /*, Identifier[] Identifiers*/)
        {
            this.Node = Node;
            //this.Identifiers = Identifiers;
        }
コード例 #15
0
        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);
        }
コード例 #16
0
 protected virtual void VisitValueExpression(
     XElement element, XAttribute attribute,
     MSBuildElementSyntax resolvedElement, MSBuildAttributeSyntax resolvedAttribute,
     ITypedSymbol valueType, MSBuildValueKind inferredKind, ExpressionNode node)
 {
 }
コード例 #17
0
ファイル: LessThanOrEqualNode.cs プロジェクト: bmallin/sbc
 public LessThanOrEqualNode(ExpressionNode lhs, ExpressionNode rhs)
     : base(lhs, rhs)
 {
 }
コード例 #18
0
 public InvocationExpressionNode WithExpression(ExpressionNode kIdentifierExpression)
 {
     kIdentifierExpression.Parent = this;
     Expression = kIdentifierExpression;
     return(this);
 }
コード例 #19
0
 /// <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;
 }
コード例 #20
0
        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()*/));
                    }
                }
            }
        }
コード例 #21
0
        /// <summary>
        /// Initializes a new instance of <see cref="DateWeekFunctionNode"/> class.
        /// </summary>
        /// <param name="parameter"></param>
        public DateWeekFunctionNode(ExpressionNode parameter)
            : base(ExpressionNodeType.DateWeek, parameter)
        {

        }
コード例 #22
0
        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);
        }
コード例 #23
0
 /// <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)
 {
 }
コード例 #24
0
 public ExpressionNode(Expression expression, ExpressionNode parent)
 {
     Expression = expression;
     Parent     = parent;
 }
コード例 #25
0
 /// <summary>
 /// Initializes a new instance of <see cref="AppraiserPartAverageFunctionNode"/> class.
 /// </summary>
 /// <param name="parameter1">Gage R&amp;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)
 {
 }
コード例 #26
0
 protected override void Visit(ExpressionNode node)
 {
     Nodes.Add(node);
 }
コード例 #27
0
 /// <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);
 }
コード例 #29
0
 /// <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)
 {
 }
コード例 #30
0
 /// <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));
        }
コード例 #32
0
 /// <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)
 {
 }
コード例 #33
0
 protected override NameNode CreateNameNode(ExpressionNode node, string tokenString)
 {
     return(new CTNameNode(node, tokenString, Context));
 }
コード例 #34
0
        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);
        }
コード例 #35
0
        /// <summary>
        /// Initializes a new instance of <see cref="DateMonthFunctionNode"/> class.
        /// </summary>
        /// <param name="parameter"></param>
        public DateMonthFunctionNode(ExpressionNode parameter)
            : base(ExpressionNodeType.DateMonth, parameter)
        {

        }
コード例 #36
0
 public override ExpressionNode Resolve(IExpressionVisitor visitor, ExpressionNode caller, ExpressionNode[] arguments)
 {
     return(new StatusNode(Status.Error, arguments.FirstOrDefault()));
 }
コード例 #37
0
 /// <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)
 {
 }
コード例 #38
0
 public override ExpressionNode Resolve(IExpressionVisitor visitor, ExpressionNode caller,
                                        ExpressionNode[] arguments)
 {
     return(new TableKeyAccessNode(caller, new ConstantValueNode(DataValueType.String, "err")));
 }
コード例 #39
0
ファイル: TrimFunctionNode.cs プロジェクト: mparsin/Elements
        /// <summary>
        /// Initializes a new instance of <see cref="TrimFunctionNode"/> class.
        /// </summary>
        /// <param name="parameter"></param>
        public TrimFunctionNode(ExpressionNode parameter)
            : base(ExpressionNodeType.Trim, parameter)
        {

        }
コード例 #40
0
 public override ExpressionNode Resolve(IExpressionVisitor visitor, ExpressionNode caller, ExpressionNode[] arguments)
 {
     return(new CastNode(DataValueType.Float, arguments.First()));
 }
コード例 #41
0
 /// <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)
 {
 }
コード例 #42
0
 public override ExpressionNode Resolve(IExpressionVisitor visitor, ExpressionNode caller, ExpressionNode[] arguments)
 {
     return(new StatusNode(Status.Ok));
 }
コード例 #43
0
ファイル: AddFunctionNode.cs プロジェクト: mparsin/Elements
 /// <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)
 {
 }
コード例 #44
0
 public GridValueNode(ExpressionNode first, ExpressionNode second, IdentifierValueNode member)
 {
     FirstD  = first;
     SecondD = second;
     Member  = member;
 }
コード例 #45
0
 public void SetChildren(ExpressionNode left, ExpressionNode right)
 {
     Left = left;
     Right = right;
 }
コード例 #46
0
 public AndExpression(ExpressionNode leftExpression, ExpressionNode rightExpression, int line, int letter) 
     : base(new List<ExpressionNode> { leftExpression, rightExpression }, line, letter) {}
コード例 #47
0
 public MultiplicationNode(ExpressionNode leftNode, ExpressionNode rightNode)
     : base(leftNode, rightNode)
 {
 }
コード例 #48
0
 public override dynamic Visit(ExpressionNode node)
 {
     return(null);
 }
コード例 #49
0
 /// <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)
 {
 }
コード例 #50
0
            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;
                }
            }
コード例 #51
0
        private void AssertIsProperty(ExpressionNode node, string name)
        {
            Assert.IsType<PropertyAccessorNode>(node);

            var p = (PropertyAccessorNode)node;
            Assert.Equal(name, p.PropertyName);
        }
コード例 #52
0
ファイル: WhileNode.cs プロジェクト: sci4me/Neo-old
 public WhileNode(SourcePosition position, ExpressionNode condition, StatementNode code) : base(position)
 {
     Condition = condition;
     Code      = code;
 }
コード例 #53
0
        private List<ExpressionNode> ToList(ExpressionNode node)
        {
            var result = new List<ExpressionNode>();
            
            while (node != null)
            {
                result.Add(node);
                node = node.Next;
            }

            return result;
        }
コード例 #54
0
 public ExpressionNode(Operator operatorMap, ExpressionNode right)
 {
     this.Operator = operatorMap;
     this.Right    = right;
 }
コード例 #55
0
 /// <summary>
 /// Initializes a new instance of <see cref="AppraiserXBarFunctionNode"/> class.
 /// </summary>
 /// <param name="parameter1">Gage R&amp;R type field</param>
 /// <param name="parameter2">Appraiser code</param>
 public GageRR_AppraiserXBarFunctionNode(ExpressionNode parameter1, ExpressionNode parameter2)
     : base(ExpressionNodeType.AppraiserXBar, parameter1, parameter2)
 {
 }
コード例 #56
0
        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;
            }
        }
コード例 #57
0
ファイル: FileReferenceVisitor.cs プロジェクト: Eilon/spark
 protected override void Visit(ExpressionNode expressionNode)
 {
 }
コード例 #58
0
 public void Set(ExpressionNode expressionNode)
 {
     this.Operator   = Operator.Noop;
     this.Expression = null;
     this.Right      = expressionNode;
 }
コード例 #59
0
 /// <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)
 {
 }
コード例 #60
0
 public virtual ASTNode Transform(ExpressionNode item)
 {
     return(item);
 }